using System;
using System.Runtime.InteropServices;
using System.Text;

namespace GLDotNet
{
	public partial class GLContext
	{
		/// glAccum
		/// Version: 1.0
		public void Accum(uint op, float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Accum);

			GLNative.Accum(op, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.Accum);
		}

		/// glAccum
		/// Version: 1.0
		public void Accum(AccumOp op, float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Accum);

			GLNative.Accum((uint)op, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.Accum);
		}

		private GLNative.ActiveTexture _ActiveTexture;

		/// glActiveTexture
		/// Version: 1.3
		public void ActiveTexture(uint texture)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ActiveTexture);

			if (this._ActiveTexture == null)
				this._ActiveTexture = (GLNative.ActiveTexture)this.LoadExtensionFunction<GLNative.ActiveTexture>();

			this._ActiveTexture(texture);

			this.AfterNativeFunctionCall(GLNativeFunctions.ActiveTexture);
		}

		/// glAlphaFunc
		/// Version: 1.0
		public void AlphaFunc(uint func, float @ref)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.AlphaFunc);

			GLNative.AlphaFunc(func, @ref);

			this.AfterNativeFunctionCall(GLNativeFunctions.AlphaFunc);
		}

		/// glAlphaFunc
		/// Version: 1.0
		public void AlphaFunc(AlphaFunction func, float @ref)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.AlphaFunc);

			GLNative.AlphaFunc((uint)func, @ref);

			this.AfterNativeFunctionCall(GLNativeFunctions.AlphaFunc);
		}

		/// glAreTexturesResident
		/// Version: 1.1
		public bool AreTexturesResident(int n, ref uint textures, out bool residences)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.AreTexturesResident);

			unsafe
			{
				fixed (uint* texturesPtr = &textures)
				fixed (bool* residencesPtr = &residences)
				{
					result = GLNative.AreTexturesResident(n, texturesPtr, residencesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.AreTexturesResident);

			return result;
		}

		/// glAreTexturesResident
		/// Version: 1.1
		public bool AreTexturesResident(int n, uint[] textures, bool[] residences)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.AreTexturesResident);

			unsafe
			{
				fixed (uint* texturesPtr = textures)
				fixed (bool* residencesPtr = residences)
				{
					result = GLNative.AreTexturesResident(n, texturesPtr, residencesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.AreTexturesResident);

			return result;
		}

		/// glArrayElement
		/// Version: 1.1
		public void ArrayElement(int i)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ArrayElement);

			GLNative.ArrayElement(i);

			this.AfterNativeFunctionCall(GLNativeFunctions.ArrayElement);
		}

		private GLNative.AttachShader _AttachShader;

		/// glAttachShader
		/// Version: 2.0
		public void AttachShader(uint program, uint shader)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.AttachShader);

			if (this._AttachShader == null)
				this._AttachShader = (GLNative.AttachShader)this.LoadExtensionFunction<GLNative.AttachShader>();

			this._AttachShader(program, shader);

			this.AfterNativeFunctionCall(GLNativeFunctions.AttachShader);
		}

		/// glBegin
		/// Version: 1.0
		public void Begin(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Begin);

			GLNative.Begin(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.Begin);
		}

		/// glBegin
		/// Version: 1.0
		public void Begin(PrimitiveType mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Begin);

			GLNative.Begin((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.Begin);
		}

		private GLNative.BeginConditionalRender _BeginConditionalRender;

		/// glBeginConditionalRender
		/// Version: 3.0
		public void BeginConditionalRender(uint id, uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BeginConditionalRender);

			if (this._BeginConditionalRender == null)
				this._BeginConditionalRender = (GLNative.BeginConditionalRender)this.LoadExtensionFunction<GLNative.BeginConditionalRender>();

			this._BeginConditionalRender(id, mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.BeginConditionalRender);
		}

		private GLNative.BeginQuery _BeginQuery;

		/// glBeginQuery
		/// Version: 1.5
		public void BeginQuery(uint target, uint id)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BeginQuery);

			if (this._BeginQuery == null)
				this._BeginQuery = (GLNative.BeginQuery)this.LoadExtensionFunction<GLNative.BeginQuery>();

			this._BeginQuery(target, id);

			this.AfterNativeFunctionCall(GLNativeFunctions.BeginQuery);
		}

		private GLNative.BeginTransformFeedback _BeginTransformFeedback;

		/// glBeginTransformFeedback
		/// Version: 3.0
		public void BeginTransformFeedback(uint primitiveMode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BeginTransformFeedback);

			if (this._BeginTransformFeedback == null)
				this._BeginTransformFeedback = (GLNative.BeginTransformFeedback)this.LoadExtensionFunction<GLNative.BeginTransformFeedback>();

			this._BeginTransformFeedback(primitiveMode);

			this.AfterNativeFunctionCall(GLNativeFunctions.BeginTransformFeedback);
		}

		private GLNative.BindAttribLocation _BindAttribLocation;

		/// glBindAttribLocation
		/// Version: 2.0
		public void BindAttribLocation(uint program, uint index, string name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindAttribLocation);

			unsafe
			{
				{
					if (this._BindAttribLocation == null)
						this._BindAttribLocation = (GLNative.BindAttribLocation)this.LoadExtensionFunction<GLNative.BindAttribLocation>();

					this._BindAttribLocation(program, index, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BindAttribLocation);
		}

		private GLNative.BindBuffer _BindBuffer;

		/// glBindBuffer
		/// Version: 1.5
		public void BindBuffer(uint target, uint buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindBuffer);

			if (this._BindBuffer == null)
				this._BindBuffer = (GLNative.BindBuffer)this.LoadExtensionFunction<GLNative.BindBuffer>();

			this._BindBuffer(target, buffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindBuffer);
		}

		private GLNative.BindBufferBase _BindBufferBase;

		/// glBindBufferBase
		/// Version: 3.0
		public void BindBufferBase(uint target, uint index, uint buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindBufferBase);

			if (this._BindBufferBase == null)
				this._BindBufferBase = (GLNative.BindBufferBase)this.LoadExtensionFunction<GLNative.BindBufferBase>();

			this._BindBufferBase(target, index, buffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindBufferBase);
		}

		private GLNative.BindBufferRange _BindBufferRange;

		/// glBindBufferRange
		/// Version: 3.0
		public void BindBufferRange(uint target, uint index, uint buffer, IntPtr offset, IntPtr size)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindBufferRange);

			if (this._BindBufferRange == null)
				this._BindBufferRange = (GLNative.BindBufferRange)this.LoadExtensionFunction<GLNative.BindBufferRange>();

			this._BindBufferRange(target, index, buffer, offset, size);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindBufferRange);
		}

		private GLNative.BindFragDataLocation _BindFragDataLocation;

		/// glBindFragDataLocation
		/// Version: 3.0
		public void BindFragDataLocation(uint program, uint color, string name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindFragDataLocation);

			unsafe
			{
				{
					if (this._BindFragDataLocation == null)
						this._BindFragDataLocation = (GLNative.BindFragDataLocation)this.LoadExtensionFunction<GLNative.BindFragDataLocation>();

					this._BindFragDataLocation(program, color, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BindFragDataLocation);
		}

		private GLNative.BindFragDataLocationIndexed _BindFragDataLocationIndexed;

		/// glBindFragDataLocationIndexed
		/// Version: 3.3
		public void BindFragDataLocationIndexed(uint program, uint colorNumber, uint index, string name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindFragDataLocationIndexed);

			unsafe
			{
				{
					if (this._BindFragDataLocationIndexed == null)
						this._BindFragDataLocationIndexed = (GLNative.BindFragDataLocationIndexed)this.LoadExtensionFunction<GLNative.BindFragDataLocationIndexed>();

					this._BindFragDataLocationIndexed(program, colorNumber, index, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BindFragDataLocationIndexed);
		}

		private GLNative.BindFramebuffer _BindFramebuffer;

		/// glBindFramebuffer
		/// Version: 3.0
		public void BindFramebuffer(uint target, uint framebuffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindFramebuffer);

			if (this._BindFramebuffer == null)
				this._BindFramebuffer = (GLNative.BindFramebuffer)this.LoadExtensionFunction<GLNative.BindFramebuffer>();

			this._BindFramebuffer(target, framebuffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindFramebuffer);
		}

		private GLNative.BindRenderbuffer _BindRenderbuffer;

		/// glBindRenderbuffer
		/// Version: 3.0
		public void BindRenderbuffer(uint target, uint renderbuffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindRenderbuffer);

			if (this._BindRenderbuffer == null)
				this._BindRenderbuffer = (GLNative.BindRenderbuffer)this.LoadExtensionFunction<GLNative.BindRenderbuffer>();

			this._BindRenderbuffer(target, renderbuffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindRenderbuffer);
		}

		private GLNative.BindSampler _BindSampler;

		/// glBindSampler
		/// Version: 3.3
		public void BindSampler(uint unit, uint sampler)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindSampler);

			if (this._BindSampler == null)
				this._BindSampler = (GLNative.BindSampler)this.LoadExtensionFunction<GLNative.BindSampler>();

			this._BindSampler(unit, sampler);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindSampler);
		}

		/// glBindTexture
		/// Version: 1.1
		public void BindTexture(uint target, uint texture)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindTexture);

			GLNative.BindTexture(target, texture);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindTexture);
		}

		/// glBindTexture
		/// Version: 1.1
		public void BindTexture(TextureTarget target, uint texture)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindTexture);

			GLNative.BindTexture((uint)target, texture);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindTexture);
		}

		private GLNative.BindVertexArray _BindVertexArray;

		/// glBindVertexArray
		/// Version: 3.0
		public void BindVertexArray(uint array)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BindVertexArray);

			if (this._BindVertexArray == null)
				this._BindVertexArray = (GLNative.BindVertexArray)this.LoadExtensionFunction<GLNative.BindVertexArray>();

			this._BindVertexArray(array);

			this.AfterNativeFunctionCall(GLNativeFunctions.BindVertexArray);
		}

		/// glBitmap
		/// Version: 1.0
		public void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Bitmap);

			unsafe
			{
				fixed (byte* bitmapPtr = bitmap)
				{
					GLNative.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmapPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Bitmap);
		}

		/// glBitmap
		/// Version: 1.0
		public void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, ref byte bitmap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Bitmap);

			unsafe
			{
				fixed (byte* bitmapPtr = &bitmap)
				{
					GLNative.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmapPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Bitmap);
		}

		private GLNative.BlendColor _BlendColor;

		/// glBlendColor
		/// Version: 1.2
		public void BlendColor(float red, float green, float blue, float alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendColor);

			if (this._BlendColor == null)
				this._BlendColor = (GLNative.BlendColor)this.LoadExtensionFunction<GLNative.BlendColor>();

			this._BlendColor(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendColor);
		}

		private GLNative.BlendEquation _BlendEquation;

		/// glBlendEquation
		/// Version: 1.2
		public void BlendEquation(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendEquation);

			if (this._BlendEquation == null)
				this._BlendEquation = (GLNative.BlendEquation)this.LoadExtensionFunction<GLNative.BlendEquation>();

			this._BlendEquation(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendEquation);
		}

		private GLNative.BlendEquationSeparate _BlendEquationSeparate;

		/// glBlendEquationSeparate
		/// Version: 2.0
		public void BlendEquationSeparate(uint modeRGB, uint modeAlpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendEquationSeparate);

			if (this._BlendEquationSeparate == null)
				this._BlendEquationSeparate = (GLNative.BlendEquationSeparate)this.LoadExtensionFunction<GLNative.BlendEquationSeparate>();

			this._BlendEquationSeparate(modeRGB, modeAlpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendEquationSeparate);
		}

		/// glBlendEquationSeparate
		/// Version: 2.0
		public void BlendEquationSeparate(BlendEquationModeEXT modeRGB, BlendEquationModeEXT modeAlpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendEquationSeparate);

			if (this._BlendEquationSeparate == null)
				this._BlendEquationSeparate = (GLNative.BlendEquationSeparate)this.LoadExtensionFunction<GLNative.BlendEquationSeparate>();

			this._BlendEquationSeparate((uint)modeRGB, (uint)modeAlpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendEquationSeparate);
		}

		/// glBlendFunc
		/// Version: 1.0
		public void BlendFunc(uint sfactor, uint dfactor)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendFunc);

			GLNative.BlendFunc(sfactor, dfactor);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendFunc);
		}

		/// glBlendFunc
		/// Version: 1.0
		public void BlendFunc(BlendingFactorSrc sfactor, BlendingFactorDest dfactor)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendFunc);

			GLNative.BlendFunc((uint)sfactor, (uint)dfactor);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendFunc);
		}

		private GLNative.BlendFuncSeparate _BlendFuncSeparate;

		/// glBlendFuncSeparate
		/// Version: 1.4
		public void BlendFuncSeparate(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlendFuncSeparate);

			if (this._BlendFuncSeparate == null)
				this._BlendFuncSeparate = (GLNative.BlendFuncSeparate)this.LoadExtensionFunction<GLNative.BlendFuncSeparate>();

			this._BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlendFuncSeparate);
		}

		private GLNative.BlitFramebuffer _BlitFramebuffer;

		/// glBlitFramebuffer
		/// Version: 3.0
		public void BlitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, uint mask, uint filter)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlitFramebuffer);

			if (this._BlitFramebuffer == null)
				this._BlitFramebuffer = (GLNative.BlitFramebuffer)this.LoadExtensionFunction<GLNative.BlitFramebuffer>();

			this._BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlitFramebuffer);
		}

		/// glBlitFramebuffer
		/// Version: 3.0
		public void BlitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, ClearBufferMask mask, uint filter)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BlitFramebuffer);

			if (this._BlitFramebuffer == null)
				this._BlitFramebuffer = (GLNative.BlitFramebuffer)this.LoadExtensionFunction<GLNative.BlitFramebuffer>();

			this._BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, (uint)mask, filter);

			this.AfterNativeFunctionCall(GLNativeFunctions.BlitFramebuffer);
		}

		private GLNative.BufferData _BufferData;

		/// glBufferData
		/// Version: 1.5
		public void BufferData<T>(uint target, IntPtr size, T[] data, uint usage) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferData == null)
						this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

					this._BufferData(target, size, (IntPtr)dataPtr.AddrOfPinnedObject(), usage);
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferData
		/// Version: 1.5
		public void BufferData(BufferTarget target, IntPtr size, IntPtr data, BufferUsage usage)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				if (this._BufferData == null)
					this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

				this._BufferData((uint)target, size, data, (uint)usage);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferData
		/// Version: 1.5
		public void BufferData<T>(BufferTarget target, IntPtr size, T[] data, BufferUsage usage) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferData == null)
						this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

					this._BufferData((uint)target, size, (IntPtr)dataPtr.AddrOfPinnedObject(), (uint)usage);
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferData
		/// Version: 1.5
		public void BufferData<T>(BufferTarget target, IntPtr size, ref T data, BufferUsage usage) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferData == null)
						this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

					this._BufferData((uint)target, size, (IntPtr)dataPtr.AddrOfPinnedObject(), (uint)usage);
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferData
		/// Version: 1.5
		public void BufferData<T>(uint target, IntPtr size, ref T data, uint usage) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferData == null)
						this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

					this._BufferData(target, size, (IntPtr)dataPtr.AddrOfPinnedObject(), usage);
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferData
		/// Version: 1.5
		public void BufferData(uint target, IntPtr size, IntPtr data, uint usage)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferData);

			unsafe
			{
				if (this._BufferData == null)
					this._BufferData = (GLNative.BufferData)this.LoadExtensionFunction<GLNative.BufferData>();

				this._BufferData(target, size, data, usage);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferData);
		}

		/// glBufferSubData
		/// Version: 1.5
		public void BufferSubData(uint target, IntPtr offset, IntPtr size, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferSubData);

			unsafe
			{
				if (this._BufferSubData == null)
					this._BufferSubData = (GLNative.BufferSubData)this.LoadExtensionFunction<GLNative.BufferSubData>();

				this._BufferSubData(target, offset, size, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferSubData);
		}

		/// glBufferSubData
		/// Version: 1.5
		public void BufferSubData<T>(uint target, IntPtr offset, IntPtr size, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferSubData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferSubData == null)
						this._BufferSubData = (GLNative.BufferSubData)this.LoadExtensionFunction<GLNative.BufferSubData>();

					this._BufferSubData(target, offset, size, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferSubData);
		}

		private GLNative.BufferSubData _BufferSubData;

		/// glBufferSubData
		/// Version: 1.5
		public void BufferSubData<T>(uint target, IntPtr offset, IntPtr size, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.BufferSubData);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._BufferSubData == null)
						this._BufferSubData = (GLNative.BufferSubData)this.LoadExtensionFunction<GLNative.BufferSubData>();

					this._BufferSubData(target, offset, size, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.BufferSubData);
		}

		/// glCallList
		/// Version: 1.0
		public void CallList(uint list)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallList);

			GLNative.CallList(list);

			this.AfterNativeFunctionCall(GLNativeFunctions.CallList);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList<T>(int n, ListNameType type, T[] lists) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GCHandle listsPtr = GCHandle.Alloc(lists, GCHandleType.Pinned);
				try
				{
					GLNative.CallLists(n, (uint)type, (IntPtr)listsPtr.AddrOfPinnedObject());
				}
				finally
				{
					listsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList<T>(int n, uint type, T[] lists) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GCHandle listsPtr = GCHandle.Alloc(lists, GCHandleType.Pinned);
				try
				{
					GLNative.CallLists(n, type, (IntPtr)listsPtr.AddrOfPinnedObject());
				}
				finally
				{
					listsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList(int n, ListNameType type, IntPtr lists)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GLNative.CallLists(n, (uint)type, lists);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList<T>(int n, ListNameType type, ref T lists) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GCHandle listsPtr = GCHandle.Alloc(lists, GCHandleType.Pinned);
				try
				{
					GLNative.CallLists(n, (uint)type, (IntPtr)listsPtr.AddrOfPinnedObject());
				}
				finally
				{
					listsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList(int n, uint type, IntPtr lists)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GLNative.CallLists(n, type, lists);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		/// glCallLists
		/// Version: 1.0
		public void CallList<T>(int n, uint type, ref T lists) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CallLists);

			unsafe
			{
				GCHandle listsPtr = GCHandle.Alloc(lists, GCHandleType.Pinned);
				try
				{
					GLNative.CallLists(n, type, (IntPtr)listsPtr.AddrOfPinnedObject());
				}
				finally
				{
					listsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CallLists);
		}

		private GLNative.CheckFramebufferStatus _CheckFramebufferStatus;

		/// glCheckFramebufferStatus
		/// Version: 3.0
		public uint CheckFramebufferStatus(uint target)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.CheckFramebufferStatus);

			if (this._CheckFramebufferStatus == null)
				this._CheckFramebufferStatus = (GLNative.CheckFramebufferStatus)this.LoadExtensionFunction<GLNative.CheckFramebufferStatus>();

			result = this._CheckFramebufferStatus(target);

			this.AfterNativeFunctionCall(GLNativeFunctions.CheckFramebufferStatus);

			return result;
		}

		private GLNative.ClampColor _ClampColor;

		/// glClampColor
		/// Version: 3.0
		public void ClampColor(uint target, uint clamp)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClampColor);

			if (this._ClampColor == null)
				this._ClampColor = (GLNative.ClampColor)this.LoadExtensionFunction<GLNative.ClampColor>();

			this._ClampColor(target, clamp);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClampColor);
		}

		/// glClear
		/// Version: 1.0
		public void Clear(ClearBufferMask mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Clear);

			GLNative.Clear((uint)mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.Clear);
		}

		/// glClear
		/// Version: 1.0
		public void Clear(uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Clear);

			GLNative.Clear(mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.Clear);
		}

		/// glClearAccum
		/// Version: 1.0
		public void ClearAccum(float red, float green, float blue, float alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearAccum);

			GLNative.ClearAccum(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearAccum);
		}

		private GLNative.ClearBufferfi _ClearBufferfi;

		/// glClearBufferfi
		/// Version: 3.0
		public void ClearBufferf(uint buffer, int drawbuffer, float depth, int stencil)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferfi);

			if (this._ClearBufferfi == null)
				this._ClearBufferfi = (GLNative.ClearBufferfi)this.LoadExtensionFunction<GLNative.ClearBufferfi>();

			this._ClearBufferfi(buffer, drawbuffer, depth, stencil);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferfi);
		}

		private GLNative.ClearBufferfv _ClearBufferfv;

		/// glClearBufferfv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferfv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._ClearBufferfv == null)
						this._ClearBufferfv = (GLNative.ClearBufferfv)this.LoadExtensionFunction<GLNative.ClearBufferfv>();

					this._ClearBufferfv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferfv);
		}

		/// glClearBufferfv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferfv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._ClearBufferfv == null)
						this._ClearBufferfv = (GLNative.ClearBufferfv)this.LoadExtensionFunction<GLNative.ClearBufferfv>();

					this._ClearBufferfv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferfv);
		}

		private GLNative.ClearBufferiv _ClearBufferiv;

		/// glClearBufferiv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, int[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferiv);

			unsafe
			{
				fixed (int* valuePtr = value)
				{
					if (this._ClearBufferiv == null)
						this._ClearBufferiv = (GLNative.ClearBufferiv)this.LoadExtensionFunction<GLNative.ClearBufferiv>();

					this._ClearBufferiv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferiv);
		}

		/// glClearBufferiv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, ref int value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferiv);

			unsafe
			{
				fixed (int* valuePtr = &value)
				{
					if (this._ClearBufferiv == null)
						this._ClearBufferiv = (GLNative.ClearBufferiv)this.LoadExtensionFunction<GLNative.ClearBufferiv>();

					this._ClearBufferiv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferiv);
		}

		private GLNative.ClearBufferuiv _ClearBufferuiv;

		/// glClearBufferuiv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferuiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._ClearBufferuiv == null)
						this._ClearBufferuiv = (GLNative.ClearBufferuiv)this.LoadExtensionFunction<GLNative.ClearBufferuiv>();

					this._ClearBufferuiv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferuiv);
		}

		/// glClearBufferuiv
		/// Version: 3.0
		public void ClearBuffer(uint buffer, int drawbuffer, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearBufferuiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._ClearBufferuiv == null)
						this._ClearBufferuiv = (GLNative.ClearBufferuiv)this.LoadExtensionFunction<GLNative.ClearBufferuiv>();

					this._ClearBufferuiv(buffer, drawbuffer, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearBufferuiv);
		}

		/// glClearColor
		/// Version: 1.0
		public void ClearColor(float red, float green, float blue, float alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearColor);

			GLNative.ClearColor(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearColor);
		}

		/// glClearDepth
		/// Version: 1.0
		public void ClearDepth(double depth)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearDepth);

			GLNative.ClearDepth(depth);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearDepth);
		}

		/// glClearIndex
		/// Version: 1.0
		public void ClearIndex(float c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearIndex);

			GLNative.ClearIndex(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearIndex);
		}

		/// glClearStencil
		/// Version: 1.0
		public void ClearStencil(int s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClearStencil);

			GLNative.ClearStencil(s);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClearStencil);
		}

		private GLNative.ClientActiveTexture _ClientActiveTexture;

		/// glClientActiveTexture
		/// Version: 1.3
		public void ClientActiveTexture(uint texture)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClientActiveTexture);

			if (this._ClientActiveTexture == null)
				this._ClientActiveTexture = (GLNative.ClientActiveTexture)this.LoadExtensionFunction<GLNative.ClientActiveTexture>();

			this._ClientActiveTexture(texture);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClientActiveTexture);
		}

		private GLNative.ClientWaitSync _ClientWaitSync;

		/// glClientWaitSync
		/// Version: 3.2
		public uint ClientWaitSync(IntPtr sync, uint flags, ulong timeout)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.ClientWaitSync);

			if (this._ClientWaitSync == null)
				this._ClientWaitSync = (GLNative.ClientWaitSync)this.LoadExtensionFunction<GLNative.ClientWaitSync>();

			result = this._ClientWaitSync(sync, flags, timeout);

			this.AfterNativeFunctionCall(GLNativeFunctions.ClientWaitSync);

			return result;
		}

		/// glClipPlane
		/// Version: 1.0
		public void ClipPlane(ClipPlaneName plane, ref double equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClipPlane);

			unsafe
			{
				fixed (double* equationPtr = &equation)
				{
					GLNative.ClipPlane((uint)plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClipPlane);
		}

		/// glClipPlane
		/// Version: 1.0
		public void ClipPlane(ClipPlaneName plane, double[] equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClipPlane);

			unsafe
			{
				fixed (double* equationPtr = equation)
				{
					GLNative.ClipPlane((uint)plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClipPlane);
		}

		/// glClipPlane
		/// Version: 1.0
		public void ClipPlane(uint plane, double[] equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClipPlane);

			unsafe
			{
				fixed (double* equationPtr = equation)
				{
					GLNative.ClipPlane(plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClipPlane);
		}

		/// glClipPlane
		/// Version: 1.0
		public void ClipPlane(uint plane, ref double equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ClipPlane);

			unsafe
			{
				fixed (double* equationPtr = &equation)
				{
					GLNative.ClipPlane(plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ClipPlane);
		}

		/// glColor3b
		/// Version: 1.0
		public void Color3(sbyte red, sbyte green, sbyte blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3b);

			GLNative.Color3b(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3b);
		}

		/// glColor3bv
		/// Version: 1.0
		public void Color3(ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					GLNative.Color3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3bv);
		}

		/// glColor3bv
		/// Version: 1.0
		public void Color3(sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					GLNative.Color3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3bv);
		}

		/// glColor3d
		/// Version: 1.0
		public void Color3(double red, double green, double blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3d);

			GLNative.Color3d(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3d);
		}

		/// glColor3dv
		/// Version: 1.0
		public void Color3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Color3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3dv);
		}

		/// glColor3dv
		/// Version: 1.0
		public void Color3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Color3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3dv);
		}

		/// glColor3f
		/// Version: 1.0
		public void Color3(float red, float green, float blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3f);

			GLNative.Color3f(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3f);
		}

		/// glColor3fv
		/// Version: 1.0
		public void Color3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Color3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3fv);
		}

		/// glColor3fv
		/// Version: 1.0
		public void Color3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Color3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3fv);
		}

		/// glColor3i
		/// Version: 1.0
		public void Color3(int red, int green, int blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3i);

			GLNative.Color3i(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3i);
		}

		/// glColor3iv
		/// Version: 1.0
		public void Color3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Color3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3iv);
		}

		/// glColor3iv
		/// Version: 1.0
		public void Color3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Color3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3iv);
		}

		/// glColor3s
		/// Version: 1.0
		public void Color3(short red, short green, short blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3s);

			GLNative.Color3s(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3s);
		}

		/// glColor3sv
		/// Version: 1.0
		public void Color3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Color3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3sv);
		}

		/// glColor3sv
		/// Version: 1.0
		public void Color3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Color3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3sv);
		}

		/// glColor3ub
		/// Version: 1.0
		public void Color3u(byte red, byte green, byte blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3ub);

			GLNative.Color3ub(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3ub);
		}

		/// glColor3ubv
		/// Version: 1.0
		public void Color3(byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3ubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					GLNative.Color3ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3ubv);
		}

		/// glColor3ubv
		/// Version: 1.0
		public void Color3(ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3ubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					GLNative.Color3ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3ubv);
		}

		/// glColor3ui
		/// Version: 1.0
		public void Color3(uint red, uint green, uint blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3ui);

			GLNative.Color3ui(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3ui);
		}

		/// glColor3uiv
		/// Version: 1.0
		public void Color3(ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					GLNative.Color3uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3uiv);
		}

		/// glColor3uiv
		/// Version: 1.0
		public void Color3(uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					GLNative.Color3uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3uiv);
		}

		/// glColor3us
		/// Version: 1.0
		public void Color3u(ushort red, ushort green, ushort blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3us);

			GLNative.Color3us(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3us);
		}

		/// glColor3usv
		/// Version: 1.0
		public void Color3(ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3usv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					GLNative.Color3usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3usv);
		}

		/// glColor3usv
		/// Version: 1.0
		public void Color3(ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color3usv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					GLNative.Color3usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color3usv);
		}

		/// glColor4b
		/// Version: 1.0
		public void Color4(sbyte red, sbyte green, sbyte blue, sbyte alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4b);

			GLNative.Color4b(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4b);
		}

		/// glColor4bv
		/// Version: 1.0
		public void Color4(sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					GLNative.Color4bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4bv);
		}

		/// glColor4bv
		/// Version: 1.0
		public void Color4(ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					GLNative.Color4bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4bv);
		}

		/// glColor4d
		/// Version: 1.0
		public void Color4(double red, double green, double blue, double alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4d);

			GLNative.Color4d(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4d);
		}

		/// glColor4dv
		/// Version: 1.0
		public void Color4(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Color4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4dv);
		}

		/// glColor4dv
		/// Version: 1.0
		public void Color4(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Color4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4dv);
		}

		/// glColor4f
		/// Version: 1.0
		public void Color4(float red, float green, float blue, float alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4f);

			GLNative.Color4f(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4f);
		}

		/// glColor4fv
		/// Version: 1.0
		public void Color4(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Color4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4fv);
		}

		/// glColor4fv
		/// Version: 1.0
		public void Color4(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Color4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4fv);
		}

		/// glColor4i
		/// Version: 1.0
		public void Color4(int red, int green, int blue, int alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4i);

			GLNative.Color4i(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4i);
		}

		/// glColor4iv
		/// Version: 1.0
		public void Color4(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Color4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4iv);
		}

		/// glColor4iv
		/// Version: 1.0
		public void Color4(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Color4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4iv);
		}

		/// glColor4s
		/// Version: 1.0
		public void Color4(short red, short green, short blue, short alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4s);

			GLNative.Color4s(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4s);
		}

		/// glColor4sv
		/// Version: 1.0
		public void Color4(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Color4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4sv);
		}

		/// glColor4sv
		/// Version: 1.0
		public void Color4(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Color4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4sv);
		}

		/// glColor4ub
		/// Version: 1.0
		public void Color4u(byte red, byte green, byte blue, byte alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4ub);

			GLNative.Color4ub(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4ub);
		}

		/// glColor4ubv
		/// Version: 1.0
		public void Color4(byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4ubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					GLNative.Color4ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4ubv);
		}

		/// glColor4ubv
		/// Version: 1.0
		public void Color4(ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4ubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					GLNative.Color4ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4ubv);
		}

		/// glColor4ui
		/// Version: 1.0
		public void Color4(uint red, uint green, uint blue, uint alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4ui);

			GLNative.Color4ui(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4ui);
		}

		/// glColor4uiv
		/// Version: 1.0
		public void Color4(ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					GLNative.Color4uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4uiv);
		}

		/// glColor4uiv
		/// Version: 1.0
		public void Color4(uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					GLNative.Color4uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4uiv);
		}

		/// glColor4us
		/// Version: 1.0
		public void Color4u(ushort red, ushort green, ushort blue, ushort alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4us);

			GLNative.Color4us(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4us);
		}

		/// glColor4usv
		/// Version: 1.0
		public void Color4(ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4usv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					GLNative.Color4usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4usv);
		}

		/// glColor4usv
		/// Version: 1.0
		public void Color4(ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Color4usv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					GLNative.Color4usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Color4usv);
		}

		/// glColorMask
		/// Version: 1.0
		public void ColorMask(bool red, bool green, bool blue, bool alpha)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorMask);

			GLNative.ColorMask(red, green, blue, alpha);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorMask);
		}

		private GLNative.ColorMaski _ColorMaski;

		/// glColorMaski
		/// Version: 3.0
		public void ColorMask(uint index, bool r, bool g, bool b, bool a)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorMaski);

			if (this._ColorMaski == null)
				this._ColorMaski = (GLNative.ColorMaski)this.LoadExtensionFunction<GLNative.ColorMaski>();

			this._ColorMaski(index, r, g, b, a);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorMaski);
		}

		/// glColorMaterial
		/// Version: 1.0
		public void ColorMaterial(MaterialFace face, ColorMaterialParameter mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorMaterial);

			GLNative.ColorMaterial((uint)face, (uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorMaterial);
		}

		/// glColorMaterial
		/// Version: 1.0
		public void ColorMaterial(uint face, uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorMaterial);

			GLNative.ColorMaterial(face, mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorMaterial);
		}

		private GLNative.ColorP3ui _ColorP3ui;

		/// glColorP3ui
		/// Version: 3.3
		public void ColorP3(uint type, uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP3ui);

			if (this._ColorP3ui == null)
				this._ColorP3ui = (GLNative.ColorP3ui)this.LoadExtensionFunction<GLNative.ColorP3ui>();

			this._ColorP3ui(type, color);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP3ui);
		}

		private GLNative.ColorP3uiv _ColorP3uiv;

		/// glColorP3uiv
		/// Version: 3.3
		public void ColorP3(uint type, uint[] color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP3uiv);

			unsafe
			{
				fixed (uint* colorPtr = color)
				{
					if (this._ColorP3uiv == null)
						this._ColorP3uiv = (GLNative.ColorP3uiv)this.LoadExtensionFunction<GLNative.ColorP3uiv>();

					this._ColorP3uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP3uiv);
		}

		/// glColorP3uiv
		/// Version: 3.3
		public void ColorP3(uint type, ref uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP3uiv);

			unsafe
			{
				fixed (uint* colorPtr = &color)
				{
					if (this._ColorP3uiv == null)
						this._ColorP3uiv = (GLNative.ColorP3uiv)this.LoadExtensionFunction<GLNative.ColorP3uiv>();

					this._ColorP3uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP3uiv);
		}

		private GLNative.ColorP4ui _ColorP4ui;

		/// glColorP4ui
		/// Version: 3.3
		public void ColorP4(uint type, uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP4ui);

			if (this._ColorP4ui == null)
				this._ColorP4ui = (GLNative.ColorP4ui)this.LoadExtensionFunction<GLNative.ColorP4ui>();

			this._ColorP4ui(type, color);

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP4ui);
		}

		/// glColorP4uiv
		/// Version: 3.3
		public void ColorP4(uint type, ref uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP4uiv);

			unsafe
			{
				fixed (uint* colorPtr = &color)
				{
					if (this._ColorP4uiv == null)
						this._ColorP4uiv = (GLNative.ColorP4uiv)this.LoadExtensionFunction<GLNative.ColorP4uiv>();

					this._ColorP4uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP4uiv);
		}

		private GLNative.ColorP4uiv _ColorP4uiv;

		/// glColorP4uiv
		/// Version: 3.3
		public void ColorP4(uint type, uint[] color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorP4uiv);

			unsafe
			{
				fixed (uint* colorPtr = color)
				{
					if (this._ColorP4uiv == null)
						this._ColorP4uiv = (GLNative.ColorP4uiv)this.LoadExtensionFunction<GLNative.ColorP4uiv>();

					this._ColorP4uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorP4uiv);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer<T>(int size, uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.ColorPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer(int size, uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GLNative.ColorPointer(size, type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer<T>(int size, ColorPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.ColorPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer(int size, ColorPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GLNative.ColorPointer(size, (uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer<T>(int size, ColorPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.ColorPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		/// glColorPointer
		/// Version: 1.1
		public void ColorPointer<T>(int size, uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.ColorPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ColorPointer);
		}

		private GLNative.CompileShader _CompileShader;

		/// glCompileShader
		/// Version: 2.0
		public void CompileShader(uint shader)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompileShader);

			if (this._CompileShader == null)
				this._CompileShader = (GLNative.CompileShader)this.LoadExtensionFunction<GLNative.CompileShader>();

			this._CompileShader(shader);

			this.AfterNativeFunctionCall(GLNativeFunctions.CompileShader);
		}

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D<T>(uint target, int level, uint internalformat, int width, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage1D == null)
						this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

					this._CompressedTexImage1D(target, level, internalformat, width, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D(TextureTarget target, int level, uint internalformat, int width, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				if (this._CompressedTexImage1D == null)
					this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

				this._CompressedTexImage1D((uint)target, level, internalformat, width, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D<T>(TextureTarget target, int level, uint internalformat, int width, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage1D == null)
						this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

					this._CompressedTexImage1D((uint)target, level, internalformat, width, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		private GLNative.CompressedTexImage1D _CompressedTexImage1D;

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D<T>(uint target, int level, uint internalformat, int width, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage1D == null)
						this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

					this._CompressedTexImage1D(target, level, internalformat, width, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D<T>(TextureTarget target, int level, uint internalformat, int width, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage1D == null)
						this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

					this._CompressedTexImage1D((uint)target, level, internalformat, width, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		/// glCompressedTexImage1D
		/// Version: 1.3
		public void CompressedTexImage1D(uint target, int level, uint internalformat, int width, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);

			unsafe
			{
				if (this._CompressedTexImage1D == null)
					this._CompressedTexImage1D = (GLNative.CompressedTexImage1D)this.LoadExtensionFunction<GLNative.CompressedTexImage1D>();

				this._CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage1D);
		}

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D<T>(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage2D == null)
						this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

					this._CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				if (this._CompressedTexImage2D == null)
					this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

				this._CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D<T>(TextureTarget target, int level, uint internalformat, int width, int height, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage2D == null)
						this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

					this._CompressedTexImage2D((uint)target, level, internalformat, width, height, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D(TextureTarget target, int level, uint internalformat, int width, int height, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				if (this._CompressedTexImage2D == null)
					this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

				this._CompressedTexImage2D((uint)target, level, internalformat, width, height, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D<T>(TextureTarget target, int level, uint internalformat, int width, int height, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage2D == null)
						this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

					this._CompressedTexImage2D((uint)target, level, internalformat, width, height, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		private GLNative.CompressedTexImage2D _CompressedTexImage2D;

		/// glCompressedTexImage2D
		/// Version: 1.3
		public void CompressedTexImage2D<T>(uint target, int level, uint internalformat, int width, int height, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage2D == null)
						this._CompressedTexImage2D = (GLNative.CompressedTexImage2D)this.LoadExtensionFunction<GLNative.CompressedTexImage2D>();

					this._CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage2D);
		}

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				if (this._CompressedTexImage3D == null)
					this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

				this._CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D(TextureTarget target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				if (this._CompressedTexImage3D == null)
					this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

				this._CompressedTexImage3D((uint)target, level, internalformat, width, height, depth, border, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D<T>(TextureTarget target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage3D == null)
						this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

					this._CompressedTexImage3D((uint)target, level, internalformat, width, height, depth, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D<T>(TextureTarget target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage3D == null)
						this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

					this._CompressedTexImage3D((uint)target, level, internalformat, width, height, depth, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D<T>(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage3D == null)
						this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

					this._CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		private GLNative.CompressedTexImage3D _CompressedTexImage3D;

		/// glCompressedTexImage3D
		/// Version: 1.3
		public void CompressedTexImage3D<T>(uint target, int level, uint internalformat, int width, int height, int depth, int border, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexImage3D == null)
						this._CompressedTexImage3D = (GLNative.CompressedTexImage3D)this.LoadExtensionFunction<GLNative.CompressedTexImage3D>();

					this._CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexImage3D);
		}

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D<T>(TextureTarget target, int level, int xoffset, int width, PixelFormat format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage1D == null)
						this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

					this._CompressedTexSubImage1D((uint)target, level, xoffset, width, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D<T>(uint target, int level, int xoffset, int width, uint format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage1D == null)
						this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

					this._CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D(uint target, int level, int xoffset, int width, uint format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				if (this._CompressedTexSubImage1D == null)
					this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

				this._CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D<T>(TextureTarget target, int level, int xoffset, int width, PixelFormat format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage1D == null)
						this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

					this._CompressedTexSubImage1D((uint)target, level, xoffset, width, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D(TextureTarget target, int level, int xoffset, int width, PixelFormat format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				if (this._CompressedTexSubImage1D == null)
					this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

				this._CompressedTexSubImage1D((uint)target, level, xoffset, width, (uint)format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		private GLNative.CompressedTexSubImage1D _CompressedTexSubImage1D;

		/// glCompressedTexSubImage1D
		/// Version: 1.3
		public void CompressedTexSubImage1D<T>(uint target, int level, int xoffset, int width, uint format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage1D == null)
						this._CompressedTexSubImage1D = (GLNative.CompressedTexSubImage1D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage1D>();

					this._CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage1D);
		}

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				if (this._CompressedTexSubImage2D == null)
					this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

				this._CompressedTexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D<T>(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage2D == null)
						this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

					this._CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D<T>(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage2D == null)
						this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

					this._CompressedTexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				if (this._CompressedTexSubImage2D == null)
					this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

				this._CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		private GLNative.CompressedTexSubImage2D _CompressedTexSubImage2D;

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D<T>(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage2D == null)
						this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

					this._CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		/// glCompressedTexSubImage2D
		/// Version: 1.3
		public void CompressedTexSubImage2D<T>(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage2D == null)
						this._CompressedTexSubImage2D = (GLNative.CompressedTexSubImage2D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage2D>();

					this._CompressedTexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage2D);
		}

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				if (this._CompressedTexSubImage3D == null)
					this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

				this._CompressedTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D<T>(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage3D == null)
						this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

					this._CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, IntPtr data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				if (this._CompressedTexSubImage3D == null)
					this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

				this._CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D<T>(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, int imageSize, ref T data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage3D == null)
						this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

					this._CompressedTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		private GLNative.CompressedTexSubImage3D _CompressedTexSubImage3D;

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D<T>(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage3D == null)
						this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

					this._CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		/// glCompressedTexSubImage3D
		/// Version: 1.3
		public void CompressedTexSubImage3D<T>(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, int imageSize, T[] data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._CompressedTexSubImage3D == null)
						this._CompressedTexSubImage3D = (GLNative.CompressedTexSubImage3D)this.LoadExtensionFunction<GLNative.CompressedTexSubImage3D>();

					this._CompressedTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, imageSize, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.CompressedTexSubImage3D);
		}

		private GLNative.CopyBufferSubData _CopyBufferSubData;

		/// glCopyBufferSubData
		/// Version: 3.1
		public void CopyBufferSubData(uint readTarget, uint writeTarget, IntPtr readOffset, IntPtr writeOffset, IntPtr size)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyBufferSubData);

			if (this._CopyBufferSubData == null)
				this._CopyBufferSubData = (GLNative.CopyBufferSubData)this.LoadExtensionFunction<GLNative.CopyBufferSubData>();

			this._CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyBufferSubData);
		}

		/// glCopyPixels
		/// Version: 1.0
		public void CopyPixels(int x, int y, int width, int height, PixelCopyType type)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyPixels);

			GLNative.CopyPixels(x, y, width, height, (uint)type);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyPixels);
		}

		/// glCopyPixels
		/// Version: 1.0
		public void CopyPixels(int x, int y, int width, int height, uint type)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyPixels);

			GLNative.CopyPixels(x, y, width, height, type);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyPixels);
		}

		/// glCopyTexImage1D
		/// Version: 1.1
		public void CopyTexImage1D(TextureTarget target, int level, uint internalformat, int x, int y, int width, int border)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexImage1D);

			GLNative.CopyTexImage1D((uint)target, level, internalformat, x, y, width, border);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexImage1D);
		}

		/// glCopyTexImage1D
		/// Version: 1.1
		public void CopyTexImage1D(uint target, int level, uint internalformat, int x, int y, int width, int border)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexImage1D);

			GLNative.CopyTexImage1D(target, level, internalformat, x, y, width, border);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexImage1D);
		}

		/// glCopyTexImage2D
		/// Version: 1.1
		public void CopyTexImage2D(uint target, int level, uint internalformat, int x, int y, int width, int height, int border)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexImage2D);

			GLNative.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexImage2D);
		}

		/// glCopyTexImage2D
		/// Version: 1.1
		public void CopyTexImage2D(TextureTarget target, int level, uint internalformat, int x, int y, int width, int height, int border)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexImage2D);

			GLNative.CopyTexImage2D((uint)target, level, internalformat, x, y, width, height, border);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexImage2D);
		}

		/// glCopyTexSubImage1D
		/// Version: 1.1
		public void CopyTexSubImage1D(uint target, int level, int xoffset, int x, int y, int width)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage1D);

			GLNative.CopyTexSubImage1D(target, level, xoffset, x, y, width);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage1D);
		}

		/// glCopyTexSubImage1D
		/// Version: 1.1
		public void CopyTexSubImage1D(TextureTarget target, int level, int xoffset, int x, int y, int width)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage1D);

			GLNative.CopyTexSubImage1D((uint)target, level, xoffset, x, y, width);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage1D);
		}

		/// glCopyTexSubImage2D
		/// Version: 1.1
		public void CopyTexSubImage2D(TextureTarget target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage2D);

			GLNative.CopyTexSubImage2D((uint)target, level, xoffset, yoffset, x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage2D);
		}

		/// glCopyTexSubImage2D
		/// Version: 1.1
		public void CopyTexSubImage2D(uint target, int level, int xoffset, int yoffset, int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage2D);

			GLNative.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage2D);
		}

		private GLNative.CopyTexSubImage3D _CopyTexSubImage3D;

		/// glCopyTexSubImage3D
		/// Version: 1.2
		public void CopyTexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage3D);

			if (this._CopyTexSubImage3D == null)
				this._CopyTexSubImage3D = (GLNative.CopyTexSubImage3D)this.LoadExtensionFunction<GLNative.CopyTexSubImage3D>();

			this._CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage3D);
		}

		/// glCopyTexSubImage3D
		/// Version: 1.2
		public void CopyTexSubImage3D(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CopyTexSubImage3D);

			if (this._CopyTexSubImage3D == null)
				this._CopyTexSubImage3D = (GLNative.CopyTexSubImage3D)this.LoadExtensionFunction<GLNative.CopyTexSubImage3D>();

			this._CopyTexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.CopyTexSubImage3D);
		}

		private GLNative.CreateProgram _CreateProgram;

		/// glCreateProgram
		/// Version: 2.0
		public uint CreateProgram()
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.CreateProgram);

			if (this._CreateProgram == null)
				this._CreateProgram = (GLNative.CreateProgram)this.LoadExtensionFunction<GLNative.CreateProgram>();

			result = this._CreateProgram();

			this.AfterNativeFunctionCall(GLNativeFunctions.CreateProgram);

			return result;
		}

		private GLNative.CreateShader _CreateShader;

		/// glCreateShader
		/// Version: 2.0
		public uint CreateShader(uint type)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.CreateShader);

			if (this._CreateShader == null)
				this._CreateShader = (GLNative.CreateShader)this.LoadExtensionFunction<GLNative.CreateShader>();

			result = this._CreateShader(type);

			this.AfterNativeFunctionCall(GLNativeFunctions.CreateShader);

			return result;
		}

		/// glCreateShader
		/// Version: 2.0
		public uint CreateShader(ShaderType type)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.CreateShader);

			if (this._CreateShader == null)
				this._CreateShader = (GLNative.CreateShader)this.LoadExtensionFunction<GLNative.CreateShader>();

			result = this._CreateShader((uint)type);

			this.AfterNativeFunctionCall(GLNativeFunctions.CreateShader);

			return result;
		}

		/// glCullFace
		/// Version: 1.0
		public void CullFace(CullFaceMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CullFace);

			GLNative.CullFace((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.CullFace);
		}

		/// glCullFace
		/// Version: 1.0
		public void CullFace(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.CullFace);

			GLNative.CullFace(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.CullFace);
		}

		private GLNative.DeleteBuffers _DeleteBuffers;

		/// glDeleteBuffers
		/// Version: 1.5
		public void DeleteBuffers(int n, uint[] buffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteBuffers);

			unsafe
			{
				fixed (uint* buffersPtr = buffers)
				{
					if (this._DeleteBuffers == null)
						this._DeleteBuffers = (GLNative.DeleteBuffers)this.LoadExtensionFunction<GLNative.DeleteBuffers>();

					this._DeleteBuffers(n, buffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteBuffers);
		}

		/// glDeleteBuffers
		/// Version: 1.5
		public void DeleteBuffers(int n, ref uint buffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteBuffers);

			unsafe
			{
				fixed (uint* buffersPtr = &buffers)
				{
					if (this._DeleteBuffers == null)
						this._DeleteBuffers = (GLNative.DeleteBuffers)this.LoadExtensionFunction<GLNative.DeleteBuffers>();

					this._DeleteBuffers(n, buffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteBuffers);
		}

		/// glDeleteFramebuffers
		/// Version: 3.0
		public void DeleteFramebuffer(int n, ref uint framebuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteFramebuffers);

			unsafe
			{
				fixed (uint* framebuffersPtr = &framebuffers)
				{
					if (this._DeleteFramebuffers == null)
						this._DeleteFramebuffers = (GLNative.DeleteFramebuffers)this.LoadExtensionFunction<GLNative.DeleteFramebuffers>();

					this._DeleteFramebuffers(n, framebuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteFramebuffers);
		}

		private GLNative.DeleteFramebuffers _DeleteFramebuffers;

		/// glDeleteFramebuffers
		/// Version: 3.0
		public void DeleteFramebuffer(int n, uint[] framebuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteFramebuffers);

			unsafe
			{
				fixed (uint* framebuffersPtr = framebuffers)
				{
					if (this._DeleteFramebuffers == null)
						this._DeleteFramebuffers = (GLNative.DeleteFramebuffers)this.LoadExtensionFunction<GLNative.DeleteFramebuffers>();

					this._DeleteFramebuffers(n, framebuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteFramebuffers);
		}

		/// glDeleteLists
		/// Version: 1.0
		public void DeleteList(uint list, int range)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteLists);

			GLNative.DeleteLists(list, range);

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteLists);
		}

		private GLNative.DeleteProgram _DeleteProgram;

		/// glDeleteProgram
		/// Version: 2.0
		public void DeleteProgram(uint program)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteProgram);

			if (this._DeleteProgram == null)
				this._DeleteProgram = (GLNative.DeleteProgram)this.LoadExtensionFunction<GLNative.DeleteProgram>();

			this._DeleteProgram(program);

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteProgram);
		}

		private GLNative.DeleteQueries _DeleteQueries;

		/// glDeleteQueries
		/// Version: 1.5
		public void DeleteQuerie(int n, uint[] ids)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteQueries);

			unsafe
			{
				fixed (uint* idsPtr = ids)
				{
					if (this._DeleteQueries == null)
						this._DeleteQueries = (GLNative.DeleteQueries)this.LoadExtensionFunction<GLNative.DeleteQueries>();

					this._DeleteQueries(n, idsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteQueries);
		}

		/// glDeleteQueries
		/// Version: 1.5
		public void DeleteQuerie(int n, ref uint ids)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteQueries);

			unsafe
			{
				fixed (uint* idsPtr = &ids)
				{
					if (this._DeleteQueries == null)
						this._DeleteQueries = (GLNative.DeleteQueries)this.LoadExtensionFunction<GLNative.DeleteQueries>();

					this._DeleteQueries(n, idsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteQueries);
		}

		private GLNative.DeleteRenderbuffers _DeleteRenderbuffers;

		/// glDeleteRenderbuffers
		/// Version: 3.0
		public void DeleteRenderbuffer(int n, uint[] renderbuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteRenderbuffers);

			unsafe
			{
				fixed (uint* renderbuffersPtr = renderbuffers)
				{
					if (this._DeleteRenderbuffers == null)
						this._DeleteRenderbuffers = (GLNative.DeleteRenderbuffers)this.LoadExtensionFunction<GLNative.DeleteRenderbuffers>();

					this._DeleteRenderbuffers(n, renderbuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteRenderbuffers);
		}

		/// glDeleteRenderbuffers
		/// Version: 3.0
		public void DeleteRenderbuffer(int n, ref uint renderbuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteRenderbuffers);

			unsafe
			{
				fixed (uint* renderbuffersPtr = &renderbuffers)
				{
					if (this._DeleteRenderbuffers == null)
						this._DeleteRenderbuffers = (GLNative.DeleteRenderbuffers)this.LoadExtensionFunction<GLNative.DeleteRenderbuffers>();

					this._DeleteRenderbuffers(n, renderbuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteRenderbuffers);
		}

		private GLNative.DeleteSamplers _DeleteSamplers;

		/// glDeleteSamplers
		/// Version: 3.3
		public void DeleteSampler(int count, uint[] samplers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteSamplers);

			unsafe
			{
				fixed (uint* samplersPtr = samplers)
				{
					if (this._DeleteSamplers == null)
						this._DeleteSamplers = (GLNative.DeleteSamplers)this.LoadExtensionFunction<GLNative.DeleteSamplers>();

					this._DeleteSamplers(count, samplersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteSamplers);
		}

		/// glDeleteSamplers
		/// Version: 3.3
		public void DeleteSampler(int count, ref uint samplers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteSamplers);

			unsafe
			{
				fixed (uint* samplersPtr = &samplers)
				{
					if (this._DeleteSamplers == null)
						this._DeleteSamplers = (GLNative.DeleteSamplers)this.LoadExtensionFunction<GLNative.DeleteSamplers>();

					this._DeleteSamplers(count, samplersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteSamplers);
		}

		private GLNative.DeleteShader _DeleteShader;

		/// glDeleteShader
		/// Version: 2.0
		public void DeleteShader(uint shader)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteShader);

			if (this._DeleteShader == null)
				this._DeleteShader = (GLNative.DeleteShader)this.LoadExtensionFunction<GLNative.DeleteShader>();

			this._DeleteShader(shader);

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteShader);
		}

		private GLNative.DeleteSync _DeleteSync;

		/// glDeleteSync
		/// Version: 3.2
		public void DeleteSync(IntPtr sync)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteSync);

			if (this._DeleteSync == null)
				this._DeleteSync = (GLNative.DeleteSync)this.LoadExtensionFunction<GLNative.DeleteSync>();

			this._DeleteSync(sync);

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteSync);
		}

		/// glDeleteTextures
		/// Version: 1.1
		public void DeleteTextures(int n, ref uint textures)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteTextures);

			unsafe
			{
				fixed (uint* texturesPtr = &textures)
				{
					GLNative.DeleteTextures(n, texturesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteTextures);
		}

		/// glDeleteTextures
		/// Version: 1.1
		public void DeleteTextures(int n, uint[] textures)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteTextures);

			unsafe
			{
				fixed (uint* texturesPtr = textures)
				{
					GLNative.DeleteTextures(n, texturesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteTextures);
		}

		private GLNative.DeleteVertexArrays _DeleteVertexArrays;

		/// glDeleteVertexArrays
		/// Version: 3.0
		public void DeleteVertexArrays(int n, uint[] arrays)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteVertexArrays);

			unsafe
			{
				fixed (uint* arraysPtr = arrays)
				{
					if (this._DeleteVertexArrays == null)
						this._DeleteVertexArrays = (GLNative.DeleteVertexArrays)this.LoadExtensionFunction<GLNative.DeleteVertexArrays>();

					this._DeleteVertexArrays(n, arraysPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteVertexArrays);
		}

		/// glDeleteVertexArrays
		/// Version: 3.0
		public void DeleteVertexArrays(int n, ref uint arrays)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DeleteVertexArrays);

			unsafe
			{
				fixed (uint* arraysPtr = &arrays)
				{
					if (this._DeleteVertexArrays == null)
						this._DeleteVertexArrays = (GLNative.DeleteVertexArrays)this.LoadExtensionFunction<GLNative.DeleteVertexArrays>();

					this._DeleteVertexArrays(n, arraysPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DeleteVertexArrays);
		}

		/// glDepthFunc
		/// Version: 1.0
		public void DepthFunc(uint func)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DepthFunc);

			GLNative.DepthFunc(func);

			this.AfterNativeFunctionCall(GLNativeFunctions.DepthFunc);
		}

		/// glDepthFunc
		/// Version: 1.0
		public void DepthFunc(DepthFunction func)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DepthFunc);

			GLNative.DepthFunc((uint)func);

			this.AfterNativeFunctionCall(GLNativeFunctions.DepthFunc);
		}

		/// glDepthMask
		/// Version: 1.0
		public void DepthMask(bool flag)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DepthMask);

			GLNative.DepthMask(flag);

			this.AfterNativeFunctionCall(GLNativeFunctions.DepthMask);
		}

		/// glDepthRange
		/// Version: 1.0
		public void DepthRange(double near, double far)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DepthRange);

			GLNative.DepthRange(near, far);

			this.AfterNativeFunctionCall(GLNativeFunctions.DepthRange);
		}

		private GLNative.DetachShader _DetachShader;

		/// glDetachShader
		/// Version: 2.0
		public void DetachShader(uint program, uint shader)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DetachShader);

			if (this._DetachShader == null)
				this._DetachShader = (GLNative.DetachShader)this.LoadExtensionFunction<GLNative.DetachShader>();

			this._DetachShader(program, shader);

			this.AfterNativeFunctionCall(GLNativeFunctions.DetachShader);
		}

		/// glDisable
		/// Version: 1.0
		public void Disable(uint cap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Disable);

			GLNative.Disable(cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.Disable);
		}

		/// glDisable
		/// Version: 1.0
		public void Disable(EnableCap cap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Disable);

			GLNative.Disable((uint)cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.Disable);
		}

		/// glDisableClientState
		/// Version: 1.1
		public void DisableClientState(uint array)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DisableClientState);

			GLNative.DisableClientState(array);

			this.AfterNativeFunctionCall(GLNativeFunctions.DisableClientState);
		}

		/// glDisableClientState
		/// Version: 1.1
		public void DisableClientState(EnableCap array)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DisableClientState);

			GLNative.DisableClientState((uint)array);

			this.AfterNativeFunctionCall(GLNativeFunctions.DisableClientState);
		}

		private GLNative.Disablei _Disablei;

		/// glDisablei
		/// Version: 3.0
		public void Disable(uint target, uint index)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Disablei);

			if (this._Disablei == null)
				this._Disablei = (GLNative.Disablei)this.LoadExtensionFunction<GLNative.Disablei>();

			this._Disablei(target, index);

			this.AfterNativeFunctionCall(GLNativeFunctions.Disablei);
		}

		private GLNative.DisableVertexAttribArray _DisableVertexAttribArray;

		/// glDisableVertexAttribArray
		/// Version: 2.0
		public void DisableVertexAttribArray(uint index)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DisableVertexAttribArray);

			if (this._DisableVertexAttribArray == null)
				this._DisableVertexAttribArray = (GLNative.DisableVertexAttribArray)this.LoadExtensionFunction<GLNative.DisableVertexAttribArray>();

			this._DisableVertexAttribArray(index);

			this.AfterNativeFunctionCall(GLNativeFunctions.DisableVertexAttribArray);
		}

		/// glDrawArrays
		/// Version: 1.1
		public void DrawArrays(uint mode, int first, int count)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawArrays);

			GLNative.DrawArrays(mode, first, count);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawArrays);
		}

		/// glDrawArrays
		/// Version: 1.1
		public void DrawArrays(PrimitiveType mode, int first, int count)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawArrays);

			GLNative.DrawArrays((uint)mode, first, count);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawArrays);
		}

		private GLNative.DrawArraysInstanced _DrawArraysInstanced;

		/// glDrawArraysInstanced
		/// Version: 3.1
		public void DrawArraysInstanced(uint mode, int first, int count, int instancecount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawArraysInstanced);

			if (this._DrawArraysInstanced == null)
				this._DrawArraysInstanced = (GLNative.DrawArraysInstanced)this.LoadExtensionFunction<GLNative.DrawArraysInstanced>();

			this._DrawArraysInstanced(mode, first, count, instancecount);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawArraysInstanced);
		}

		/// glDrawArraysInstanced
		/// Version: 3.1
		public void DrawArraysInstanced(PrimitiveType mode, int first, int count, int instancecount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawArraysInstanced);

			if (this._DrawArraysInstanced == null)
				this._DrawArraysInstanced = (GLNative.DrawArraysInstanced)this.LoadExtensionFunction<GLNative.DrawArraysInstanced>();

			this._DrawArraysInstanced((uint)mode, first, count, instancecount);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawArraysInstanced);
		}

		/// glDrawBuffer
		/// Version: 1.0
		public void DrawBuffer(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawBuffer);

			GLNative.DrawBuffer(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawBuffer);
		}

		/// glDrawBuffer
		/// Version: 1.0
		public void DrawBuffer(DrawBufferMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawBuffer);

			GLNative.DrawBuffer((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawBuffer);
		}

		private GLNative.DrawBuffers _DrawBuffers;

		/// glDrawBuffers
		/// Version: 2.0
		public void DrawBuffers(int n, uint[] bufs)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawBuffers);

			unsafe
			{
				fixed (uint* bufsPtr = bufs)
				{
					if (this._DrawBuffers == null)
						this._DrawBuffers = (GLNative.DrawBuffers)this.LoadExtensionFunction<GLNative.DrawBuffers>();

					this._DrawBuffers(n, bufsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawBuffers);
		}

		/// glDrawBuffers
		/// Version: 2.0
		public void DrawBuffers(int n, ref uint bufs)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawBuffers);

			unsafe
			{
				fixed (uint* bufsPtr = &bufs)
				{
					if (this._DrawBuffers == null)
						this._DrawBuffers = (GLNative.DrawBuffers)this.LoadExtensionFunction<GLNative.DrawBuffers>();

					this._DrawBuffers(n, bufsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawBuffers);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements<T>(uint mode, int count, uint type, T[] indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					GLNative.DrawElements(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements<T>(PrimitiveType mode, int count, DrawElementsType type, T[] indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					GLNative.DrawElements((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements<T>(uint mode, int count, uint type, ref T indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					GLNative.DrawElements(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements(uint mode, int count, uint type, IntPtr indices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GLNative.DrawElements(mode, count, type, indices);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements<T>(PrimitiveType mode, int count, DrawElementsType type, ref T indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					GLNative.DrawElements((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElements
		/// Version: 1.1
		public void DrawElements(PrimitiveType mode, int count, DrawElementsType type, IntPtr indices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElements);

			unsafe
			{
				GLNative.DrawElements((uint)mode, count, (uint)type, indices);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElements);
		}

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex<T>(uint mode, int count, uint type, ref T indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsBaseVertex == null)
						this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

					this._DrawElementsBaseVertex(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex(uint mode, int count, uint type, IntPtr indices, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				if (this._DrawElementsBaseVertex == null)
					this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

				this._DrawElementsBaseVertex(mode, count, type, indices, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex<T>(PrimitiveType mode, int count, DrawElementsType type, ref T indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsBaseVertex == null)
						this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

					this._DrawElementsBaseVertex((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex(PrimitiveType mode, int count, DrawElementsType type, IntPtr indices, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				if (this._DrawElementsBaseVertex == null)
					this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

				this._DrawElementsBaseVertex((uint)mode, count, (uint)type, indices, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex<T>(PrimitiveType mode, int count, DrawElementsType type, T[] indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsBaseVertex == null)
						this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

					this._DrawElementsBaseVertex((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		private GLNative.DrawElementsBaseVertex _DrawElementsBaseVertex;

		/// glDrawElementsBaseVertex
		/// Version: 3.2
		public void DrawElementsBaseVertex<T>(uint mode, int count, uint type, T[] indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsBaseVertex == null)
						this._DrawElementsBaseVertex = (GLNative.DrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsBaseVertex>();

					this._DrawElementsBaseVertex(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsBaseVertex);
		}

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced<T>(PrimitiveType mode, int count, DrawElementsType type, T[] indices, int instancecount) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstanced == null)
						this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

					this._DrawElementsInstanced((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced<T>(uint mode, int count, uint type, ref T indices, int instancecount) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstanced == null)
						this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

					this._DrawElementsInstanced(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced(uint mode, int count, uint type, IntPtr indices, int instancecount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				if (this._DrawElementsInstanced == null)
					this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

				this._DrawElementsInstanced(mode, count, type, indices, instancecount);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced<T>(PrimitiveType mode, int count, DrawElementsType type, ref T indices, int instancecount) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstanced == null)
						this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

					this._DrawElementsInstanced((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced(PrimitiveType mode, int count, DrawElementsType type, IntPtr indices, int instancecount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				if (this._DrawElementsInstanced == null)
					this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

				this._DrawElementsInstanced((uint)mode, count, (uint)type, indices, instancecount);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		private GLNative.DrawElementsInstanced _DrawElementsInstanced;

		/// glDrawElementsInstanced
		/// Version: 3.1
		public void DrawElementsInstanced<T>(uint mode, int count, uint type, T[] indices, int instancecount) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstanced == null)
						this._DrawElementsInstanced = (GLNative.DrawElementsInstanced)this.LoadExtensionFunction<GLNative.DrawElementsInstanced>();

					this._DrawElementsInstanced(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstanced);
		}

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex<T>(PrimitiveType mode, int count, DrawElementsType type, T[] indices, int instancecount, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstancedBaseVertex == null)
						this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

					this._DrawElementsInstancedBaseVertex((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount, basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex(uint mode, int count, uint type, IntPtr indices, int instancecount, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				if (this._DrawElementsInstancedBaseVertex == null)
					this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

				this._DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex(PrimitiveType mode, int count, DrawElementsType type, IntPtr indices, int instancecount, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				if (this._DrawElementsInstancedBaseVertex == null)
					this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

				this._DrawElementsInstancedBaseVertex((uint)mode, count, (uint)type, indices, instancecount, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex<T>(PrimitiveType mode, int count, DrawElementsType type, ref T indices, int instancecount, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstancedBaseVertex == null)
						this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

					this._DrawElementsInstancedBaseVertex((uint)mode, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount, basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex<T>(uint mode, int count, uint type, ref T indices, int instancecount, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstancedBaseVertex == null)
						this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

					this._DrawElementsInstancedBaseVertex(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount, basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		private GLNative.DrawElementsInstancedBaseVertex _DrawElementsInstancedBaseVertex;

		/// glDrawElementsInstancedBaseVertex
		/// Version: 3.2
		public void DrawElementsInstancedBaseVertex<T>(uint mode, int count, uint type, T[] indices, int instancecount, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawElementsInstancedBaseVertex == null)
						this._DrawElementsInstancedBaseVertex = (GLNative.DrawElementsInstancedBaseVertex)this.LoadExtensionFunction<GLNative.DrawElementsInstancedBaseVertex>();

					this._DrawElementsInstancedBaseVertex(mode, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), instancecount, basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawElementsInstancedBaseVertex);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels(int width, int height, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GLNative.DrawPixels(width, height, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels<T>(int width, int height, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.DrawPixels(width, height, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels(int width, int height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GLNative.DrawPixels(width, height, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels<T>(int width, int height, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.DrawPixels(width, height, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels<T>(int width, int height, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.DrawPixels(width, height, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawPixels
		/// Version: 1.0
		public void DrawPixels<T>(int width, int height, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawPixels);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.DrawPixels(width, height, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawPixels);
		}

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements<T>(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, ref T indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElements == null)
						this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

					this._DrawRangeElements((uint)mode, start, end, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		private GLNative.DrawRangeElements _DrawRangeElements;

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements<T>(uint mode, uint start, uint end, int count, uint type, T[] indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElements == null)
						this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

					this._DrawRangeElements(mode, start, end, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements<T>(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, T[] indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElements == null)
						this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

					this._DrawRangeElements((uint)mode, start, end, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements<T>(uint mode, uint start, uint end, int count, uint type, ref T indices) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElements == null)
						this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

					this._DrawRangeElements(mode, start, end, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject());
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, IntPtr indices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				if (this._DrawRangeElements == null)
					this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

				this._DrawRangeElements((uint)mode, start, end, count, (uint)type, indices);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		/// glDrawRangeElements
		/// Version: 1.2
		public void DrawRangeElements(uint mode, uint start, uint end, int count, uint type, IntPtr indices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElements);

			unsafe
			{
				if (this._DrawRangeElements == null)
					this._DrawRangeElements = (GLNative.DrawRangeElements)this.LoadExtensionFunction<GLNative.DrawRangeElements>();

				this._DrawRangeElements(mode, start, end, count, type, indices);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElements);
		}

		private GLNative.DrawRangeElementsBaseVertex _DrawRangeElementsBaseVertex;

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex<T>(uint mode, uint start, uint end, int count, uint type, T[] indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElementsBaseVertex == null)
						this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

					this._DrawRangeElementsBaseVertex(mode, start, end, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex<T>(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, T[] indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElementsBaseVertex == null)
						this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

					this._DrawRangeElementsBaseVertex((uint)mode, start, end, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex<T>(uint mode, uint start, uint end, int count, uint type, ref T indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElementsBaseVertex == null)
						this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

					this._DrawRangeElementsBaseVertex(mode, start, end, count, type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex(uint mode, uint start, uint end, int count, uint type, IntPtr indices, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				if (this._DrawRangeElementsBaseVertex == null)
					this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

				this._DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex<T>(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, ref T indices, int basevertex) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				GCHandle indicesPtr = GCHandle.Alloc(indices, GCHandleType.Pinned);
				try
				{
					if (this._DrawRangeElementsBaseVertex == null)
						this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

					this._DrawRangeElementsBaseVertex((uint)mode, start, end, count, (uint)type, (IntPtr)indicesPtr.AddrOfPinnedObject(), basevertex);
				}
				finally
				{
					indicesPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glDrawRangeElementsBaseVertex
		/// Version: 3.2
		public void DrawRangeElementsBaseVertex(PrimitiveType mode, uint start, uint end, int count, DrawElementsType type, IntPtr indices, int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);

			unsafe
			{
				if (this._DrawRangeElementsBaseVertex == null)
					this._DrawRangeElementsBaseVertex = (GLNative.DrawRangeElementsBaseVertex)this.LoadExtensionFunction<GLNative.DrawRangeElementsBaseVertex>();

				this._DrawRangeElementsBaseVertex((uint)mode, start, end, count, (uint)type, indices, basevertex);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.DrawRangeElementsBaseVertex);
		}

		/// glEdgeFlag
		/// Version: 1.0
		public void EdgeFlag(bool flag)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EdgeFlag);

			GLNative.EdgeFlag(flag);

			this.AfterNativeFunctionCall(GLNativeFunctions.EdgeFlag);
		}

		/// glEdgeFlagPointer
		/// Version: 1.1
		public void EdgeFlagPointer<T>(int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.EdgeFlagPointer(stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);
		}

		/// glEdgeFlagPointer
		/// Version: 1.1
		public void EdgeFlagPointer(int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);

			unsafe
			{
				GLNative.EdgeFlagPointer(stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);
		}

		/// glEdgeFlagPointer
		/// Version: 1.1
		public void EdgeFlagPointer<T>(int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.EdgeFlagPointer(stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EdgeFlagPointer);
		}

		/// glEdgeFlagv
		/// Version: 1.0
		public void EdgeFlag(bool[] flag)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EdgeFlagv);

			unsafe
			{
				fixed (bool* flagPtr = flag)
				{
					GLNative.EdgeFlagv(flagPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EdgeFlagv);
		}

		/// glEnable
		/// Version: 1.0
		public void Enable(uint cap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Enable);

			GLNative.Enable(cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.Enable);
		}

		/// glEnable
		/// Version: 1.0
		public void Enable(EnableCap cap)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Enable);

			GLNative.Enable((uint)cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.Enable);
		}

		/// glEnableClientState
		/// Version: 1.1
		public void EnableClientState(uint array)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EnableClientState);

			GLNative.EnableClientState(array);

			this.AfterNativeFunctionCall(GLNativeFunctions.EnableClientState);
		}

		/// glEnableClientState
		/// Version: 1.1
		public void EnableClientState(EnableCap array)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EnableClientState);

			GLNative.EnableClientState((uint)array);

			this.AfterNativeFunctionCall(GLNativeFunctions.EnableClientState);
		}

		private GLNative.Enablei _Enablei;

		/// glEnablei
		/// Version: 3.0
		public void Enable(uint target, uint index)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Enablei);

			if (this._Enablei == null)
				this._Enablei = (GLNative.Enablei)this.LoadExtensionFunction<GLNative.Enablei>();

			this._Enablei(target, index);

			this.AfterNativeFunctionCall(GLNativeFunctions.Enablei);
		}

		private GLNative.EnableVertexAttribArray _EnableVertexAttribArray;

		/// glEnableVertexAttribArray
		/// Version: 2.0
		public void EnableVertexAttribArray(uint index)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EnableVertexAttribArray);

			if (this._EnableVertexAttribArray == null)
				this._EnableVertexAttribArray = (GLNative.EnableVertexAttribArray)this.LoadExtensionFunction<GLNative.EnableVertexAttribArray>();

			this._EnableVertexAttribArray(index);

			this.AfterNativeFunctionCall(GLNativeFunctions.EnableVertexAttribArray);
		}

		/// glEnd
		/// Version: 1.0
		public void End()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.End);

			GLNative.End();

			this.AfterNativeFunctionCall(GLNativeFunctions.End);
		}

		private GLNative.EndConditionalRender _EndConditionalRender;

		/// glEndConditionalRender
		/// Version: 3.0
		public void EndConditionalRender()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EndConditionalRender);

			if (this._EndConditionalRender == null)
				this._EndConditionalRender = (GLNative.EndConditionalRender)this.LoadExtensionFunction<GLNative.EndConditionalRender>();

			this._EndConditionalRender();

			this.AfterNativeFunctionCall(GLNativeFunctions.EndConditionalRender);
		}

		/// glEndList
		/// Version: 1.0
		public void EndList()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EndList);

			GLNative.EndList();

			this.AfterNativeFunctionCall(GLNativeFunctions.EndList);
		}

		private GLNative.EndQuery _EndQuery;

		/// glEndQuery
		/// Version: 1.5
		public void EndQuery(uint target)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EndQuery);

			if (this._EndQuery == null)
				this._EndQuery = (GLNative.EndQuery)this.LoadExtensionFunction<GLNative.EndQuery>();

			this._EndQuery(target);

			this.AfterNativeFunctionCall(GLNativeFunctions.EndQuery);
		}

		private GLNative.EndTransformFeedback _EndTransformFeedback;

		/// glEndTransformFeedback
		/// Version: 3.0
		public void EndTransformFeedback()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EndTransformFeedback);

			if (this._EndTransformFeedback == null)
				this._EndTransformFeedback = (GLNative.EndTransformFeedback)this.LoadExtensionFunction<GLNative.EndTransformFeedback>();

			this._EndTransformFeedback();

			this.AfterNativeFunctionCall(GLNativeFunctions.EndTransformFeedback);
		}

		/// glEvalCoord1d
		/// Version: 1.0
		public void EvalCoord1(double u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1d);

			GLNative.EvalCoord1d(u);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1d);
		}

		/// glEvalCoord1dv
		/// Version: 1.0
		public void EvalCoord1(double[] u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1dv);

			unsafe
			{
				fixed (double* uPtr = u)
				{
					GLNative.EvalCoord1dv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1dv);
		}

		/// glEvalCoord1dv
		/// Version: 1.0
		public void EvalCoord1(ref double u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1dv);

			unsafe
			{
				fixed (double* uPtr = &u)
				{
					GLNative.EvalCoord1dv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1dv);
		}

		/// glEvalCoord1f
		/// Version: 1.0
		public void EvalCoord1(float u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1f);

			GLNative.EvalCoord1f(u);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1f);
		}

		/// glEvalCoord1fv
		/// Version: 1.0
		public void EvalCoord1(float[] u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1fv);

			unsafe
			{
				fixed (float* uPtr = u)
				{
					GLNative.EvalCoord1fv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1fv);
		}

		/// glEvalCoord1fv
		/// Version: 1.0
		public void EvalCoord1(ref float u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord1fv);

			unsafe
			{
				fixed (float* uPtr = &u)
				{
					GLNative.EvalCoord1fv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord1fv);
		}

		/// glEvalCoord2d
		/// Version: 1.0
		public void EvalCoord2(double u, double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2d);

			GLNative.EvalCoord2d(u, v);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2d);
		}

		/// glEvalCoord2dv
		/// Version: 1.0
		public void EvalCoord2(ref double u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2dv);

			unsafe
			{
				fixed (double* uPtr = &u)
				{
					GLNative.EvalCoord2dv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2dv);
		}

		/// glEvalCoord2dv
		/// Version: 1.0
		public void EvalCoord2(double[] u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2dv);

			unsafe
			{
				fixed (double* uPtr = u)
				{
					GLNative.EvalCoord2dv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2dv);
		}

		/// glEvalCoord2f
		/// Version: 1.0
		public void EvalCoord2(float u, float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2f);

			GLNative.EvalCoord2f(u, v);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2f);
		}

		/// glEvalCoord2fv
		/// Version: 1.0
		public void EvalCoord2(float[] u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2fv);

			unsafe
			{
				fixed (float* uPtr = u)
				{
					GLNative.EvalCoord2fv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2fv);
		}

		/// glEvalCoord2fv
		/// Version: 1.0
		public void EvalCoord2(ref float u)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalCoord2fv);

			unsafe
			{
				fixed (float* uPtr = &u)
				{
					GLNative.EvalCoord2fv(uPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalCoord2fv);
		}

		/// glEvalMesh1
		/// Version: 1.0
		public void EvalMesh1(MeshMode1 mode, int i1, int i2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalMesh1);

			GLNative.EvalMesh1((uint)mode, i1, i2);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalMesh1);
		}

		/// glEvalMesh1
		/// Version: 1.0
		public void EvalMesh1(uint mode, int i1, int i2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalMesh1);

			GLNative.EvalMesh1(mode, i1, i2);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalMesh1);
		}

		/// glEvalMesh2
		/// Version: 1.0
		public void EvalMesh2(uint mode, int i1, int i2, int j1, int j2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalMesh2);

			GLNative.EvalMesh2(mode, i1, i2, j1, j2);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalMesh2);
		}

		/// glEvalMesh2
		/// Version: 1.0
		public void EvalMesh2(MeshMode2 mode, int i1, int i2, int j1, int j2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalMesh2);

			GLNative.EvalMesh2((uint)mode, i1, i2, j1, j2);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalMesh2);
		}

		/// glEvalPoint1
		/// Version: 1.0
		public void EvalPoint1(int i)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalPoint1);

			GLNative.EvalPoint1(i);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalPoint1);
		}

		/// glEvalPoint2
		/// Version: 1.0
		public void EvalPoint2(int i, int j)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.EvalPoint2);

			GLNative.EvalPoint2(i, j);

			this.AfterNativeFunctionCall(GLNativeFunctions.EvalPoint2);
		}

		/// glFeedbackBuffer
		/// Version: 1.0
		public void FeedbackBuffer(int size, uint type, out float buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);

			unsafe
			{
				fixed (float* bufferPtr = &buffer)
				{
					GLNative.FeedbackBuffer(size, type, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);
		}

		/// glFeedbackBuffer
		/// Version: 1.0
		public void FeedbackBuffer(int size, FeedbackType type, out float buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);

			unsafe
			{
				fixed (float* bufferPtr = &buffer)
				{
					GLNative.FeedbackBuffer(size, (uint)type, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);
		}

		/// glFeedbackBuffer
		/// Version: 1.0
		public void FeedbackBuffer(int size, uint type, float[] buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);

			unsafe
			{
				fixed (float* bufferPtr = buffer)
				{
					GLNative.FeedbackBuffer(size, type, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);
		}

		/// glFeedbackBuffer
		/// Version: 1.0
		public void FeedbackBuffer(int size, FeedbackType type, float[] buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);

			unsafe
			{
				fixed (float* bufferPtr = buffer)
				{
					GLNative.FeedbackBuffer(size, (uint)type, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FeedbackBuffer);
		}

		private GLNative.FenceSync _FenceSync;

		/// glFenceSync
		/// Version: 3.2
		public IntPtr FenceSync(uint condition, uint flags)
		{
			IntPtr result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.FenceSync);

			if (this._FenceSync == null)
				this._FenceSync = (GLNative.FenceSync)this.LoadExtensionFunction<GLNative.FenceSync>();

			result = this._FenceSync(condition, flags);

			this.AfterNativeFunctionCall(GLNativeFunctions.FenceSync);

			return result;
		}

		/// glFinish
		/// Version: 1.0
		public void Finish()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Finish);

			GLNative.Finish();

			this.AfterNativeFunctionCall(GLNativeFunctions.Finish);
		}

		/// glFlush
		/// Version: 1.0
		public void Flush()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Flush);

			GLNative.Flush();

			this.AfterNativeFunctionCall(GLNativeFunctions.Flush);
		}

		private GLNative.FlushMappedBufferRange _FlushMappedBufferRange;

		/// glFlushMappedBufferRange
		/// Version: 3.0
		public void FlushMappedBufferRange(uint target, IntPtr offset, IntPtr length)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FlushMappedBufferRange);

			if (this._FlushMappedBufferRange == null)
				this._FlushMappedBufferRange = (GLNative.FlushMappedBufferRange)this.LoadExtensionFunction<GLNative.FlushMappedBufferRange>();

			this._FlushMappedBufferRange(target, offset, length);

			this.AfterNativeFunctionCall(GLNativeFunctions.FlushMappedBufferRange);
		}

		private GLNative.FogCoordd _FogCoordd;

		/// glFogCoordd
		/// Version: 1.4
		public void FogCoord(double coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordd);

			if (this._FogCoordd == null)
				this._FogCoordd = (GLNative.FogCoordd)this.LoadExtensionFunction<GLNative.FogCoordd>();

			this._FogCoordd(coord);

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordd);
		}

		private GLNative.FogCoorddv _FogCoorddv;

		/// glFogCoorddv
		/// Version: 1.4
		public void FogCoord(double[] coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoorddv);

			unsafe
			{
				fixed (double* coordPtr = coord)
				{
					if (this._FogCoorddv == null)
						this._FogCoorddv = (GLNative.FogCoorddv)this.LoadExtensionFunction<GLNative.FogCoorddv>();

					this._FogCoorddv(coordPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoorddv);
		}

		/// glFogCoorddv
		/// Version: 1.4
		public void FogCoord(ref double coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoorddv);

			unsafe
			{
				fixed (double* coordPtr = &coord)
				{
					if (this._FogCoorddv == null)
						this._FogCoorddv = (GLNative.FogCoorddv)this.LoadExtensionFunction<GLNative.FogCoorddv>();

					this._FogCoorddv(coordPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoorddv);
		}

		private GLNative.FogCoordf _FogCoordf;

		/// glFogCoordf
		/// Version: 1.4
		public void FogCoord(float coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordf);

			if (this._FogCoordf == null)
				this._FogCoordf = (GLNative.FogCoordf)this.LoadExtensionFunction<GLNative.FogCoordf>();

			this._FogCoordf(coord);

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordf);
		}

		/// glFogCoordfv
		/// Version: 1.4
		public void FogCoord(ref float coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordfv);

			unsafe
			{
				fixed (float* coordPtr = &coord)
				{
					if (this._FogCoordfv == null)
						this._FogCoordfv = (GLNative.FogCoordfv)this.LoadExtensionFunction<GLNative.FogCoordfv>();

					this._FogCoordfv(coordPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordfv);
		}

		private GLNative.FogCoordfv _FogCoordfv;

		/// glFogCoordfv
		/// Version: 1.4
		public void FogCoord(float[] coord)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordfv);

			unsafe
			{
				fixed (float* coordPtr = coord)
				{
					if (this._FogCoordfv == null)
						this._FogCoordfv = (GLNative.FogCoordfv)this.LoadExtensionFunction<GLNative.FogCoordfv>();

					this._FogCoordfv(coordPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordfv);
		}

		/// glFogCoordPointer
		/// Version: 1.4
		public void FogCoordPointer<T>(uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._FogCoordPointer == null)
						this._FogCoordPointer = (GLNative.FogCoordPointer)this.LoadExtensionFunction<GLNative.FogCoordPointer>();

					this._FogCoordPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordPointer);
		}

		private GLNative.FogCoordPointer _FogCoordPointer;

		/// glFogCoordPointer
		/// Version: 1.4
		public void FogCoordPointer<T>(uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._FogCoordPointer == null)
						this._FogCoordPointer = (GLNative.FogCoordPointer)this.LoadExtensionFunction<GLNative.FogCoordPointer>();

					this._FogCoordPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordPointer);
		}

		/// glFogCoordPointer
		/// Version: 1.4
		public void FogCoordPointer(uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FogCoordPointer);

			unsafe
			{
				if (this._FogCoordPointer == null)
					this._FogCoordPointer = (GLNative.FogCoordPointer)this.LoadExtensionFunction<GLNative.FogCoordPointer>();

				this._FogCoordPointer(type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.FogCoordPointer);
		}

		/// glFogf
		/// Version: 1.0
		public void Fog(uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogf);

			GLNative.Fogf(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogf);
		}

		/// glFogf
		/// Version: 1.0
		public void Fog(FogParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogf);

			GLNative.Fogf((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogf);
		}

		/// glFogfv
		/// Version: 1.0
		public void Fog(FogParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Fogfv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogfv);
		}

		/// glFogfv
		/// Version: 1.0
		public void Fog(uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Fogfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogfv);
		}

		/// glFogfv
		/// Version: 1.0
		public void Fog(uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Fogfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogfv);
		}

		/// glFogfv
		/// Version: 1.0
		public void Fog(FogParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Fogfv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogfv);
		}

		/// glFogi
		/// Version: 1.0
		public void Fog(FogParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogi);

			GLNative.Fogi((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogi);
		}

		/// glFogi
		/// Version: 1.0
		public void Fog(uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogi);

			GLNative.Fogi(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogi);
		}

		/// glFogiv
		/// Version: 1.0
		public void Fog(uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Fogiv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogiv);
		}

		/// glFogiv
		/// Version: 1.0
		public void Fog(FogParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Fogiv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogiv);
		}

		/// glFogiv
		/// Version: 1.0
		public void Fog(FogParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Fogiv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogiv);
		}

		/// glFogiv
		/// Version: 1.0
		public void Fog(uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Fogiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Fogiv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Fogiv);
		}

		private GLNative.FramebufferRenderbuffer _FramebufferRenderbuffer;

		/// glFramebufferRenderbuffer
		/// Version: 3.0
		public void FramebufferRenderbuffer(uint target, uint attachment, uint renderbuffertarget, uint renderbuffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferRenderbuffer);

			if (this._FramebufferRenderbuffer == null)
				this._FramebufferRenderbuffer = (GLNative.FramebufferRenderbuffer)this.LoadExtensionFunction<GLNative.FramebufferRenderbuffer>();

			this._FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferRenderbuffer);
		}

		private GLNative.FramebufferTexture _FramebufferTexture;

		/// glFramebufferTexture
		/// Version: 3.2
		public void FramebufferTexture(uint target, uint attachment, uint texture, int level)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferTexture);

			if (this._FramebufferTexture == null)
				this._FramebufferTexture = (GLNative.FramebufferTexture)this.LoadExtensionFunction<GLNative.FramebufferTexture>();

			this._FramebufferTexture(target, attachment, texture, level);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferTexture);
		}

		private GLNative.FramebufferTexture1D _FramebufferTexture1D;

		/// glFramebufferTexture1D
		/// Version: 3.0
		public void FramebufferTexture1D(uint target, uint attachment, uint textarget, uint texture, int level)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferTexture1D);

			if (this._FramebufferTexture1D == null)
				this._FramebufferTexture1D = (GLNative.FramebufferTexture1D)this.LoadExtensionFunction<GLNative.FramebufferTexture1D>();

			this._FramebufferTexture1D(target, attachment, textarget, texture, level);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferTexture1D);
		}

		private GLNative.FramebufferTexture2D _FramebufferTexture2D;

		/// glFramebufferTexture2D
		/// Version: 3.0
		public void FramebufferTexture2D(uint target, uint attachment, uint textarget, uint texture, int level)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferTexture2D);

			if (this._FramebufferTexture2D == null)
				this._FramebufferTexture2D = (GLNative.FramebufferTexture2D)this.LoadExtensionFunction<GLNative.FramebufferTexture2D>();

			this._FramebufferTexture2D(target, attachment, textarget, texture, level);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferTexture2D);
		}

		private GLNative.FramebufferTexture3D _FramebufferTexture3D;

		/// glFramebufferTexture3D
		/// Version: 3.0
		public void FramebufferTexture3D(uint target, uint attachment, uint textarget, uint texture, int level, int zoffset)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferTexture3D);

			if (this._FramebufferTexture3D == null)
				this._FramebufferTexture3D = (GLNative.FramebufferTexture3D)this.LoadExtensionFunction<GLNative.FramebufferTexture3D>();

			this._FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferTexture3D);
		}

		private GLNative.FramebufferTextureLayer _FramebufferTextureLayer;

		/// glFramebufferTextureLayer
		/// Version: 3.0
		public void FramebufferTextureLayer(uint target, uint attachment, uint texture, int level, int layer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FramebufferTextureLayer);

			if (this._FramebufferTextureLayer == null)
				this._FramebufferTextureLayer = (GLNative.FramebufferTextureLayer)this.LoadExtensionFunction<GLNative.FramebufferTextureLayer>();

			this._FramebufferTextureLayer(target, attachment, texture, level, layer);

			this.AfterNativeFunctionCall(GLNativeFunctions.FramebufferTextureLayer);
		}

		/// glFrontFace
		/// Version: 1.0
		public void FrontFace(FrontFaceDirection mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FrontFace);

			GLNative.FrontFace((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.FrontFace);
		}

		/// glFrontFace
		/// Version: 1.0
		public void FrontFace(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.FrontFace);

			GLNative.FrontFace(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.FrontFace);
		}

		/// glFrustum
		/// Version: 1.0
		public void Frustum(double left, double right, double bottom, double top, double zNear, double zFar)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Frustum);

			GLNative.Frustum(left, right, bottom, top, zNear, zFar);

			this.AfterNativeFunctionCall(GLNativeFunctions.Frustum);
		}

		private GLNative.GenBuffers _GenBuffers;

		/// glGenBuffers
		/// Version: 1.5
		public void GenBuffers(int n, uint[] buffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenBuffers);

			unsafe
			{
				fixed (uint* buffersPtr = buffers)
				{
					if (this._GenBuffers == null)
						this._GenBuffers = (GLNative.GenBuffers)this.LoadExtensionFunction<GLNative.GenBuffers>();

					this._GenBuffers(n, buffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenBuffers);
		}

		/// glGenBuffers
		/// Version: 1.5
		public void GenBuffers(int n, out uint buffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenBuffers);

			unsafe
			{
				fixed (uint* buffersPtr = &buffers)
				{
					if (this._GenBuffers == null)
						this._GenBuffers = (GLNative.GenBuffers)this.LoadExtensionFunction<GLNative.GenBuffers>();

					this._GenBuffers(n, buffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenBuffers);
		}

		private GLNative.GenerateMipmap _GenerateMipmap;

		/// glGenerateMipmap
		/// Version: 3.0
		public void GenerateMipmap(uint target)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenerateMipmap);

			if (this._GenerateMipmap == null)
				this._GenerateMipmap = (GLNative.GenerateMipmap)this.LoadExtensionFunction<GLNative.GenerateMipmap>();

			this._GenerateMipmap(target);

			this.AfterNativeFunctionCall(GLNativeFunctions.GenerateMipmap);
		}

		/// glGenFramebuffers
		/// Version: 3.0
		public void GenFramebuffer(int n, out uint framebuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenFramebuffers);

			unsafe
			{
				fixed (uint* framebuffersPtr = &framebuffers)
				{
					if (this._GenFramebuffers == null)
						this._GenFramebuffers = (GLNative.GenFramebuffers)this.LoadExtensionFunction<GLNative.GenFramebuffers>();

					this._GenFramebuffers(n, framebuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenFramebuffers);
		}

		private GLNative.GenFramebuffers _GenFramebuffers;

		/// glGenFramebuffers
		/// Version: 3.0
		public void GenFramebuffer(int n, uint[] framebuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenFramebuffers);

			unsafe
			{
				fixed (uint* framebuffersPtr = framebuffers)
				{
					if (this._GenFramebuffers == null)
						this._GenFramebuffers = (GLNative.GenFramebuffers)this.LoadExtensionFunction<GLNative.GenFramebuffers>();

					this._GenFramebuffers(n, framebuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenFramebuffers);
		}

		/// glGenLists
		/// Version: 1.0
		public uint GenList(int range)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GenLists);

			result = GLNative.GenLists(range);

			this.AfterNativeFunctionCall(GLNativeFunctions.GenLists);

			return result;
		}

		/// glGenQueries
		/// Version: 1.5
		public void GenQuerie(int n, out uint ids)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenQueries);

			unsafe
			{
				fixed (uint* idsPtr = &ids)
				{
					if (this._GenQueries == null)
						this._GenQueries = (GLNative.GenQueries)this.LoadExtensionFunction<GLNative.GenQueries>();

					this._GenQueries(n, idsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenQueries);
		}

		private GLNative.GenQueries _GenQueries;

		/// glGenQueries
		/// Version: 1.5
		public void GenQuerie(int n, uint[] ids)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenQueries);

			unsafe
			{
				fixed (uint* idsPtr = ids)
				{
					if (this._GenQueries == null)
						this._GenQueries = (GLNative.GenQueries)this.LoadExtensionFunction<GLNative.GenQueries>();

					this._GenQueries(n, idsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenQueries);
		}

		private GLNative.GenRenderbuffers _GenRenderbuffers;

		/// glGenRenderbuffers
		/// Version: 3.0
		public void GenRenderbuffer(int n, uint[] renderbuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenRenderbuffers);

			unsafe
			{
				fixed (uint* renderbuffersPtr = renderbuffers)
				{
					if (this._GenRenderbuffers == null)
						this._GenRenderbuffers = (GLNative.GenRenderbuffers)this.LoadExtensionFunction<GLNative.GenRenderbuffers>();

					this._GenRenderbuffers(n, renderbuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenRenderbuffers);
		}

		/// glGenRenderbuffers
		/// Version: 3.0
		public void GenRenderbuffer(int n, out uint renderbuffers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenRenderbuffers);

			unsafe
			{
				fixed (uint* renderbuffersPtr = &renderbuffers)
				{
					if (this._GenRenderbuffers == null)
						this._GenRenderbuffers = (GLNative.GenRenderbuffers)this.LoadExtensionFunction<GLNative.GenRenderbuffers>();

					this._GenRenderbuffers(n, renderbuffersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenRenderbuffers);
		}

		private GLNative.GenSamplers _GenSamplers;

		/// glGenSamplers
		/// Version: 3.3
		public void GenSampler(int count, uint[] samplers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenSamplers);

			unsafe
			{
				fixed (uint* samplersPtr = samplers)
				{
					if (this._GenSamplers == null)
						this._GenSamplers = (GLNative.GenSamplers)this.LoadExtensionFunction<GLNative.GenSamplers>();

					this._GenSamplers(count, samplersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenSamplers);
		}

		/// glGenSamplers
		/// Version: 3.3
		public void GenSampler(int count, out uint samplers)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenSamplers);

			unsafe
			{
				fixed (uint* samplersPtr = &samplers)
				{
					if (this._GenSamplers == null)
						this._GenSamplers = (GLNative.GenSamplers)this.LoadExtensionFunction<GLNative.GenSamplers>();

					this._GenSamplers(count, samplersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenSamplers);
		}

		/// glGenTextures
		/// Version: 1.1
		public void GenTextures(int n, uint[] textures)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenTextures);

			unsafe
			{
				fixed (uint* texturesPtr = textures)
				{
					GLNative.GenTextures(n, texturesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenTextures);
		}

		/// glGenTextures
		/// Version: 1.1
		public void GenTextures(int n, out uint textures)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenTextures);

			unsafe
			{
				fixed (uint* texturesPtr = &textures)
				{
					GLNative.GenTextures(n, texturesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenTextures);
		}

		private GLNative.GenVertexArrays _GenVertexArrays;

		/// glGenVertexArrays
		/// Version: 3.0
		public void GenVertexArrays(int n, uint[] arrays)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenVertexArrays);

			unsafe
			{
				fixed (uint* arraysPtr = arrays)
				{
					if (this._GenVertexArrays == null)
						this._GenVertexArrays = (GLNative.GenVertexArrays)this.LoadExtensionFunction<GLNative.GenVertexArrays>();

					this._GenVertexArrays(n, arraysPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenVertexArrays);
		}

		/// glGenVertexArrays
		/// Version: 3.0
		public void GenVertexArrays(int n, out uint arrays)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GenVertexArrays);

			unsafe
			{
				fixed (uint* arraysPtr = &arrays)
				{
					if (this._GenVertexArrays == null)
						this._GenVertexArrays = (GLNative.GenVertexArrays)this.LoadExtensionFunction<GLNative.GenVertexArrays>();

					this._GenVertexArrays(n, arraysPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GenVertexArrays);
		}

		private GLNative.GetActiveAttrib _GetActiveAttrib;

		/// glGetActiveAttrib
		/// Version: 2.0
		public void GetActiveAttrib(uint program, uint index, int bufSize, int[] length, int[] size, uint[] type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveAttrib);

			unsafe
			{
				fixed (int* lengthPtr = length)
				fixed (int* sizePtr = size)
				fixed (uint* typePtr = type)
				{
					if (this._GetActiveAttrib == null)
						this._GetActiveAttrib = (GLNative.GetActiveAttrib)this.LoadExtensionFunction<GLNative.GetActiveAttrib>();

					this._GetActiveAttrib(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveAttrib);
		}

		/// glGetActiveAttrib
		/// Version: 2.0
		public void GetActiveAttrib(uint program, uint index, int bufSize, out int length, out int size, out uint type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveAttrib);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				fixed (int* sizePtr = &size)
				fixed (uint* typePtr = &type)
				{
					if (this._GetActiveAttrib == null)
						this._GetActiveAttrib = (GLNative.GetActiveAttrib)this.LoadExtensionFunction<GLNative.GetActiveAttrib>();

					this._GetActiveAttrib(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveAttrib);
		}

		/// glGetActiveUniform
		/// Version: 2.0
		public void GetActiveUniform(uint program, uint index, int bufSize, out int length, out int size, out uint type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniform);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				fixed (int* sizePtr = &size)
				fixed (uint* typePtr = &type)
				{
					if (this._GetActiveUniform == null)
						this._GetActiveUniform = (GLNative.GetActiveUniform)this.LoadExtensionFunction<GLNative.GetActiveUniform>();

					this._GetActiveUniform(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniform);
		}

		private GLNative.GetActiveUniform _GetActiveUniform;

		/// glGetActiveUniform
		/// Version: 2.0
		public void GetActiveUniform(uint program, uint index, int bufSize, int[] length, int[] size, uint[] type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniform);

			unsafe
			{
				fixed (int* lengthPtr = length)
				fixed (int* sizePtr = size)
				fixed (uint* typePtr = type)
				{
					if (this._GetActiveUniform == null)
						this._GetActiveUniform = (GLNative.GetActiveUniform)this.LoadExtensionFunction<GLNative.GetActiveUniform>();

					this._GetActiveUniform(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniform);
		}

		private GLNative.GetActiveUniformBlockiv _GetActiveUniformBlockiv;

		/// glGetActiveUniformBlockiv
		/// Version: 3.1
		public void GetActiveUniformBlock(uint program, uint uniformBlockIndex, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetActiveUniformBlockiv == null)
						this._GetActiveUniformBlockiv = (GLNative.GetActiveUniformBlockiv)this.LoadExtensionFunction<GLNative.GetActiveUniformBlockiv>();

					this._GetActiveUniformBlockiv(program, uniformBlockIndex, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockiv);
		}

		/// glGetActiveUniformBlockiv
		/// Version: 3.1
		public void GetActiveUniformBlock(uint program, uint uniformBlockIndex, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetActiveUniformBlockiv == null)
						this._GetActiveUniformBlockiv = (GLNative.GetActiveUniformBlockiv)this.LoadExtensionFunction<GLNative.GetActiveUniformBlockiv>();

					this._GetActiveUniformBlockiv(program, uniformBlockIndex, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockiv);
		}

		private GLNative.GetActiveUniformBlockName _GetActiveUniformBlockName;

		/// glGetActiveUniformBlockName
		/// Version: 3.1
		public void GetActiveUniformBlockName(uint program, uint uniformBlockIndex, int bufSize, int[] length, StringBuilder uniformBlockName)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockName);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._GetActiveUniformBlockName == null)
						this._GetActiveUniformBlockName = (GLNative.GetActiveUniformBlockName)this.LoadExtensionFunction<GLNative.GetActiveUniformBlockName>();

					this._GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, lengthPtr, uniformBlockName);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockName);
		}

		/// glGetActiveUniformBlockName
		/// Version: 3.1
		public void GetActiveUniformBlockName(uint program, uint uniformBlockIndex, int bufSize, out int length, StringBuilder uniformBlockName)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockName);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._GetActiveUniformBlockName == null)
						this._GetActiveUniformBlockName = (GLNative.GetActiveUniformBlockName)this.LoadExtensionFunction<GLNative.GetActiveUniformBlockName>();

					this._GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, lengthPtr, uniformBlockName);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformBlockName);
		}

		/// glGetActiveUniformName
		/// Version: 3.1
		public void GetActiveUniformName(uint program, uint uniformIndex, int bufSize, out int length, StringBuilder uniformName)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformName);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._GetActiveUniformName == null)
						this._GetActiveUniformName = (GLNative.GetActiveUniformName)this.LoadExtensionFunction<GLNative.GetActiveUniformName>();

					this._GetActiveUniformName(program, uniformIndex, bufSize, lengthPtr, uniformName);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformName);
		}

		private GLNative.GetActiveUniformName _GetActiveUniformName;

		/// glGetActiveUniformName
		/// Version: 3.1
		public void GetActiveUniformName(uint program, uint uniformIndex, int bufSize, int[] length, StringBuilder uniformName)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformName);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._GetActiveUniformName == null)
						this._GetActiveUniformName = (GLNative.GetActiveUniformName)this.LoadExtensionFunction<GLNative.GetActiveUniformName>();

					this._GetActiveUniformName(program, uniformIndex, bufSize, lengthPtr, uniformName);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformName);
		}

		/// glGetActiveUniformsiv
		/// Version: 3.1
		public void GetActiveUniforms(uint program, int uniformCount, ref uint uniformIndices, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformsiv);

			unsafe
			{
				fixed (uint* uniformIndicesPtr = &uniformIndices)
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetActiveUniformsiv == null)
						this._GetActiveUniformsiv = (GLNative.GetActiveUniformsiv)this.LoadExtensionFunction<GLNative.GetActiveUniformsiv>();

					this._GetActiveUniformsiv(program, uniformCount, uniformIndicesPtr, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformsiv);
		}

		private GLNative.GetActiveUniformsiv _GetActiveUniformsiv;

		/// glGetActiveUniformsiv
		/// Version: 3.1
		public void GetActiveUniforms(uint program, int uniformCount, uint[] uniformIndices, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetActiveUniformsiv);

			unsafe
			{
				fixed (uint* uniformIndicesPtr = uniformIndices)
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetActiveUniformsiv == null)
						this._GetActiveUniformsiv = (GLNative.GetActiveUniformsiv)this.LoadExtensionFunction<GLNative.GetActiveUniformsiv>();

					this._GetActiveUniformsiv(program, uniformCount, uniformIndicesPtr, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetActiveUniformsiv);
		}

		/// glGetAttachedShaders
		/// Version: 2.0
		public void GetAttachedShader(uint program, int maxCount, out int count, uint[] shaders)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetAttachedShaders);

			unsafe
			{
				fixed (int* countPtr = &count)
				fixed (uint* shadersPtr = shaders)
				{
					if (this._GetAttachedShaders == null)
						this._GetAttachedShaders = (GLNative.GetAttachedShaders)this.LoadExtensionFunction<GLNative.GetAttachedShaders>();

					this._GetAttachedShaders(program, maxCount, countPtr, shadersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetAttachedShaders);
		}

		private GLNative.GetAttachedShaders _GetAttachedShaders;

		/// glGetAttachedShaders
		/// Version: 2.0
		public void GetAttachedShader(uint program, int maxCount, int[] count, uint[] shaders)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetAttachedShaders);

			unsafe
			{
				fixed (int* countPtr = count)
				fixed (uint* shadersPtr = shaders)
				{
					if (this._GetAttachedShaders == null)
						this._GetAttachedShaders = (GLNative.GetAttachedShaders)this.LoadExtensionFunction<GLNative.GetAttachedShaders>();

					this._GetAttachedShaders(program, maxCount, countPtr, shadersPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetAttachedShaders);
		}

		private GLNative.GetAttribLocation _GetAttribLocation;

		/// glGetAttribLocation
		/// Version: 2.0
		public int GetAttribLocation(uint program, string name)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetAttribLocation);

			unsafe
			{
				{
					if (this._GetAttribLocation == null)
						this._GetAttribLocation = (GLNative.GetAttribLocation)this.LoadExtensionFunction<GLNative.GetAttribLocation>();

					result = this._GetAttribLocation(program, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetAttribLocation);

			return result;
		}

		/// glGetBooleani_v
		/// Version: 3.0
		public void GetBoolean(uint target, uint index, out bool data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleani_v);

			unsafe
			{
				fixed (bool* dataPtr = &data)
				{
					if (this._GetBooleani_v == null)
						this._GetBooleani_v = (GLNative.GetBooleani_v)this.LoadExtensionFunction<GLNative.GetBooleani_v>();

					this._GetBooleani_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleani_v);
		}

		private GLNative.GetBooleani_v _GetBooleani_v;

		/// glGetBooleani_v
		/// Version: 3.0
		public void GetBoolean(uint target, uint index, bool[] data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleani_v);

			unsafe
			{
				fixed (bool* dataPtr = data)
				{
					if (this._GetBooleani_v == null)
						this._GetBooleani_v = (GLNative.GetBooleani_v)this.LoadExtensionFunction<GLNative.GetBooleani_v>();

					this._GetBooleani_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleani_v);
		}

		/// glGetBooleanv
		/// Version: 1.0
		public void GetBoolean(GetPName pname, bool[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleanv);

			unsafe
			{
				fixed (bool* @paramsPtr = @params)
				{
					GLNative.GetBooleanv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleanv);
		}

		/// glGetBooleanv
		/// Version: 1.0
		public void GetBoolean(uint pname, bool[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleanv);

			unsafe
			{
				fixed (bool* @paramsPtr = @params)
				{
					GLNative.GetBooleanv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleanv);
		}

		/// glGetBooleanv
		/// Version: 1.0
		public void GetBoolean(uint pname, out bool @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleanv);

			unsafe
			{
				fixed (bool* @paramsPtr = &@params)
				{
					GLNative.GetBooleanv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleanv);
		}

		/// glGetBooleanv
		/// Version: 1.0
		public void GetBoolean(GetPName pname, out bool @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBooleanv);

			unsafe
			{
				fixed (bool* @paramsPtr = &@params)
				{
					GLNative.GetBooleanv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBooleanv);
		}

		private GLNative.GetBufferParameteri64v _GetBufferParameteri64v;

		/// glGetBufferParameteri64v
		/// Version: 3.2
		public void GetBufferParameteri64(uint target, uint pname, long[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferParameteri64v);

			unsafe
			{
				fixed (long* @paramsPtr = @params)
				{
					if (this._GetBufferParameteri64v == null)
						this._GetBufferParameteri64v = (GLNative.GetBufferParameteri64v)this.LoadExtensionFunction<GLNative.GetBufferParameteri64v>();

					this._GetBufferParameteri64v(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferParameteri64v);
		}

		/// glGetBufferParameteri64v
		/// Version: 3.2
		public void GetBufferParameteri64(uint target, uint pname, out long @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferParameteri64v);

			unsafe
			{
				fixed (long* @paramsPtr = &@params)
				{
					if (this._GetBufferParameteri64v == null)
						this._GetBufferParameteri64v = (GLNative.GetBufferParameteri64v)this.LoadExtensionFunction<GLNative.GetBufferParameteri64v>();

					this._GetBufferParameteri64v(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferParameteri64v);
		}

		private GLNative.GetBufferParameteriv _GetBufferParameteriv;

		/// glGetBufferParameteriv
		/// Version: 1.5
		public void GetBufferParameter(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetBufferParameteriv == null)
						this._GetBufferParameteriv = (GLNative.GetBufferParameteriv)this.LoadExtensionFunction<GLNative.GetBufferParameteriv>();

					this._GetBufferParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferParameteriv);
		}

		/// glGetBufferParameteriv
		/// Version: 1.5
		public void GetBufferParameter(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetBufferParameteriv == null)
						this._GetBufferParameteriv = (GLNative.GetBufferParameteriv)this.LoadExtensionFunction<GLNative.GetBufferParameteriv>();

					this._GetBufferParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferParameteriv);
		}

		private GLNative.GetBufferPointerv _GetBufferPointerv;

		/// glGetBufferPointerv
		/// Version: 1.5
		public void GetBufferPointer(uint target, uint pname, out IntPtr @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferPointerv);

			@params = default(IntPtr);

			unsafe
			{
				if (this._GetBufferPointerv == null)
					this._GetBufferPointerv = (GLNative.GetBufferPointerv)this.LoadExtensionFunction<GLNative.GetBufferPointerv>();

				this._GetBufferPointerv(target, pname, @params);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferPointerv);
		}

		private GLNative.GetBufferSubData _GetBufferSubData;

		/// glGetBufferSubData
		/// Version: 1.5
		public void GetBufferSubData<T>(uint target, IntPtr offset, IntPtr size, out IntPtr data) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetBufferSubData);

			data = default(IntPtr);

			unsafe
			{
				GCHandle dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
				try
				{
					if (this._GetBufferSubData == null)
						this._GetBufferSubData = (GLNative.GetBufferSubData)this.LoadExtensionFunction<GLNative.GetBufferSubData>();

					this._GetBufferSubData(target, offset, size, (IntPtr)dataPtr.AddrOfPinnedObject());
				}
				finally
				{
					dataPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetBufferSubData);
		}

		/// glGetClipPlane
		/// Version: 1.0
		public void GetClipPlane(uint plane, double[] equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetClipPlane);

			unsafe
			{
				fixed (double* equationPtr = equation)
				{
					GLNative.GetClipPlane(plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetClipPlane);
		}

		/// glGetClipPlane
		/// Version: 1.0
		public void GetClipPlane(uint plane, out double equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetClipPlane);

			unsafe
			{
				fixed (double* equationPtr = &equation)
				{
					GLNative.GetClipPlane(plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetClipPlane);
		}

		/// glGetClipPlane
		/// Version: 1.0
		public void GetClipPlane(ClipPlaneName plane, out double equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetClipPlane);

			unsafe
			{
				fixed (double* equationPtr = &equation)
				{
					GLNative.GetClipPlane((uint)plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetClipPlane);
		}

		/// glGetClipPlane
		/// Version: 1.0
		public void GetClipPlane(ClipPlaneName plane, double[] equation)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetClipPlane);

			unsafe
			{
				fixed (double* equationPtr = equation)
				{
					GLNative.GetClipPlane((uint)plane, equationPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetClipPlane);
		}

		/// glGetCompressedTexImage
		/// Version: 1.3
		public void GetCompressedTexImage<T>(TextureTarget target, int level, IntPtr img) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetCompressedTexImage);

			unsafe
			{
				GCHandle imgPtr = GCHandle.Alloc(img, GCHandleType.Pinned);
				try
				{
					if (this._GetCompressedTexImage == null)
						this._GetCompressedTexImage = (GLNative.GetCompressedTexImage)this.LoadExtensionFunction<GLNative.GetCompressedTexImage>();

					this._GetCompressedTexImage((uint)target, level, (IntPtr)imgPtr.AddrOfPinnedObject());
				}
				finally
				{
					imgPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetCompressedTexImage);
		}

		private GLNative.GetCompressedTexImage _GetCompressedTexImage;

		/// glGetCompressedTexImage
		/// Version: 1.3
		public void GetCompressedTexImage<T>(uint target, int level, out IntPtr img) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetCompressedTexImage);

			img = default(IntPtr);

			unsafe
			{
				GCHandle imgPtr = GCHandle.Alloc(img, GCHandleType.Pinned);
				try
				{
					if (this._GetCompressedTexImage == null)
						this._GetCompressedTexImage = (GLNative.GetCompressedTexImage)this.LoadExtensionFunction<GLNative.GetCompressedTexImage>();

					this._GetCompressedTexImage(target, level, (IntPtr)imgPtr.AddrOfPinnedObject());
				}
				finally
				{
					imgPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetCompressedTexImage);
		}

		/// glGetDoublev
		/// Version: 1.0
		public void GetDouble(uint pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetDoublev);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.GetDoublev(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetDoublev);
		}

		/// glGetDoublev
		/// Version: 1.0
		public void GetDouble(GetPName pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetDoublev);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.GetDoublev((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetDoublev);
		}

		/// glGetDoublev
		/// Version: 1.0
		public void GetDouble(uint pname, out double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetDoublev);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.GetDoublev(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetDoublev);
		}

		/// glGetDoublev
		/// Version: 1.0
		public void GetDouble(GetPName pname, out double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetDoublev);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.GetDoublev((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetDoublev);
		}

		/// glGetError
		/// Version: 1.0
		public ErrorCode GetError()
		{
			ErrorCode result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetError);

			result = GLNative.GetError();

			this.AfterNativeFunctionCall(GLNativeFunctions.GetError);

			return result;
		}

		/// glGetFloatv
		/// Version: 1.0
		public void GetFloat(uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFloatv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetFloatv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFloatv);
		}

		/// glGetFloatv
		/// Version: 1.0
		public void GetFloat(GetPName pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFloatv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetFloatv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFloatv);
		}

		/// glGetFloatv
		/// Version: 1.0
		public void GetFloat(GetPName pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFloatv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetFloatv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFloatv);
		}

		/// glGetFloatv
		/// Version: 1.0
		public void GetFloat(uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFloatv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetFloatv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFloatv);
		}

		private GLNative.GetFragDataIndex _GetFragDataIndex;

		/// glGetFragDataIndex
		/// Version: 3.3
		public int GetFragDataIndex(uint program, string name)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFragDataIndex);

			unsafe
			{
				{
					if (this._GetFragDataIndex == null)
						this._GetFragDataIndex = (GLNative.GetFragDataIndex)this.LoadExtensionFunction<GLNative.GetFragDataIndex>();

					result = this._GetFragDataIndex(program, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFragDataIndex);

			return result;
		}

		private GLNative.GetFragDataLocation _GetFragDataLocation;

		/// glGetFragDataLocation
		/// Version: 3.0
		public int GetFragDataLocation(uint program, string name)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFragDataLocation);

			unsafe
			{
				{
					if (this._GetFragDataLocation == null)
						this._GetFragDataLocation = (GLNative.GetFragDataLocation)this.LoadExtensionFunction<GLNative.GetFragDataLocation>();

					result = this._GetFragDataLocation(program, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFragDataLocation);

			return result;
		}

		private GLNative.GetFramebufferAttachmentParameteriv _GetFramebufferAttachmentParameteriv;

		/// glGetFramebufferAttachmentParameteriv
		/// Version: 3.0
		public void GetFramebufferAttachmentParameter(uint target, uint attachment, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFramebufferAttachmentParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetFramebufferAttachmentParameteriv == null)
						this._GetFramebufferAttachmentParameteriv = (GLNative.GetFramebufferAttachmentParameteriv)this.LoadExtensionFunction<GLNative.GetFramebufferAttachmentParameteriv>();

					this._GetFramebufferAttachmentParameteriv(target, attachment, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFramebufferAttachmentParameteriv);
		}

		/// glGetFramebufferAttachmentParameteriv
		/// Version: 3.0
		public void GetFramebufferAttachmentParameter(uint target, uint attachment, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetFramebufferAttachmentParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetFramebufferAttachmentParameteriv == null)
						this._GetFramebufferAttachmentParameteriv = (GLNative.GetFramebufferAttachmentParameteriv)this.LoadExtensionFunction<GLNative.GetFramebufferAttachmentParameteriv>();

					this._GetFramebufferAttachmentParameteriv(target, attachment, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetFramebufferAttachmentParameteriv);
		}

		/// glGetInteger64i_v
		/// Version: 3.2
		public void GetInteger64(uint target, uint index, out long data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetInteger64i_v);

			unsafe
			{
				fixed (long* dataPtr = &data)
				{
					if (this._GetInteger64i_v == null)
						this._GetInteger64i_v = (GLNative.GetInteger64i_v)this.LoadExtensionFunction<GLNative.GetInteger64i_v>();

					this._GetInteger64i_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetInteger64i_v);
		}

		private GLNative.GetInteger64i_v _GetInteger64i_v;

		/// glGetInteger64i_v
		/// Version: 3.2
		public void GetInteger64(uint target, uint index, long[] data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetInteger64i_v);

			unsafe
			{
				fixed (long* dataPtr = data)
				{
					if (this._GetInteger64i_v == null)
						this._GetInteger64i_v = (GLNative.GetInteger64i_v)this.LoadExtensionFunction<GLNative.GetInteger64i_v>();

					this._GetInteger64i_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetInteger64i_v);
		}

		/// glGetInteger64v
		/// Version: 3.2
		public void GetInteger64(uint pname, out long @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetInteger64v);

			unsafe
			{
				fixed (long* @paramsPtr = &@params)
				{
					if (this._GetInteger64v == null)
						this._GetInteger64v = (GLNative.GetInteger64v)this.LoadExtensionFunction<GLNative.GetInteger64v>();

					this._GetInteger64v(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetInteger64v);
		}

		private GLNative.GetInteger64v _GetInteger64v;

		/// glGetInteger64v
		/// Version: 3.2
		public void GetInteger64(uint pname, long[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetInteger64v);

			unsafe
			{
				fixed (long* @paramsPtr = @params)
				{
					if (this._GetInteger64v == null)
						this._GetInteger64v = (GLNative.GetInteger64v)this.LoadExtensionFunction<GLNative.GetInteger64v>();

					this._GetInteger64v(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetInteger64v);
		}

		private GLNative.GetIntegeri_v _GetIntegeri_v;

		/// glGetIntegeri_v
		/// Version: 3.0
		public void GetInteger(uint target, uint index, int[] data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegeri_v);

			unsafe
			{
				fixed (int* dataPtr = data)
				{
					if (this._GetIntegeri_v == null)
						this._GetIntegeri_v = (GLNative.GetIntegeri_v)this.LoadExtensionFunction<GLNative.GetIntegeri_v>();

					this._GetIntegeri_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegeri_v);
		}

		/// glGetIntegeri_v
		/// Version: 3.0
		public void GetInteger(uint target, uint index, out int data)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegeri_v);

			unsafe
			{
				fixed (int* dataPtr = &data)
				{
					if (this._GetIntegeri_v == null)
						this._GetIntegeri_v = (GLNative.GetIntegeri_v)this.LoadExtensionFunction<GLNative.GetIntegeri_v>();

					this._GetIntegeri_v(target, index, dataPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegeri_v);
		}

		/// glGetIntegerv
		/// Version: 1.0
		public void GetInteger(uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegerv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetIntegerv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegerv);
		}

		/// glGetIntegerv
		/// Version: 1.0
		public void GetInteger(GetPName pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegerv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetIntegerv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegerv);
		}

		/// glGetIntegerv
		/// Version: 1.0
		public void GetInteger(GetPName pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegerv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetIntegerv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegerv);
		}

		/// glGetIntegerv
		/// Version: 1.0
		public void GetInteger(uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetIntegerv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetIntegerv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetIntegerv);
		}

		/// glGetLightfv
		/// Version: 1.0
		public void GetLight(uint light, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetLightfv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightfv);
		}

		/// glGetLightfv
		/// Version: 1.0
		public void GetLight(LightName light, LightParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetLightfv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightfv);
		}

		/// glGetLightfv
		/// Version: 1.0
		public void GetLight(LightName light, LightParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetLightfv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightfv);
		}

		/// glGetLightfv
		/// Version: 1.0
		public void GetLight(uint light, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetLightfv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightfv);
		}

		/// glGetLightiv
		/// Version: 1.0
		public void GetLight(LightName light, LightParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetLightiv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightiv);
		}

		/// glGetLightiv
		/// Version: 1.0
		public void GetLight(LightName light, LightParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetLightiv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightiv);
		}

		/// glGetLightiv
		/// Version: 1.0
		public void GetLight(uint light, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetLightiv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightiv);
		}

		/// glGetLightiv
		/// Version: 1.0
		public void GetLight(uint light, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetLightiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetLightiv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetLightiv);
		}

		/// glGetMapdv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapdv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.GetMapdv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapdv);
		}

		/// glGetMapdv
		/// Version: 1.0
		public void GetMap(uint target, uint query, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapdv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.GetMapdv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapdv);
		}

		/// glGetMapdv
		/// Version: 1.0
		public void GetMap(uint target, uint query, out double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapdv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.GetMapdv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapdv);
		}

		/// glGetMapdv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, out double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapdv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.GetMapdv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapdv);
		}

		/// glGetMapfv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapfv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.GetMapfv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapfv);
		}

		/// glGetMapfv
		/// Version: 1.0
		public void GetMap(uint target, uint query, out float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapfv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.GetMapfv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapfv);
		}

		/// glGetMapfv
		/// Version: 1.0
		public void GetMap(uint target, uint query, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapfv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.GetMapfv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapfv);
		}

		/// glGetMapfv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, out float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapfv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.GetMapfv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapfv);
		}

		/// glGetMapiv
		/// Version: 1.0
		public void GetMap(uint target, uint query, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapiv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.GetMapiv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapiv);
		}

		/// glGetMapiv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, out int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapiv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.GetMapiv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapiv);
		}

		/// glGetMapiv
		/// Version: 1.0
		public void GetMap(uint target, uint query, out int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapiv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.GetMapiv(target, query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapiv);
		}

		/// glGetMapiv
		/// Version: 1.0
		public void GetMap(MapTarget target, GetMapQuery query, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMapiv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.GetMapiv((uint)target, (uint)query, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMapiv);
		}

		/// glGetMaterialfv
		/// Version: 1.0
		public void GetMaterial(MaterialFace face, MaterialParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetMaterialfv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialfv);
		}

		/// glGetMaterialfv
		/// Version: 1.0
		public void GetMaterial(uint face, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetMaterialfv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialfv);
		}

		/// glGetMaterialfv
		/// Version: 1.0
		public void GetMaterial(uint face, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetMaterialfv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialfv);
		}

		/// glGetMaterialfv
		/// Version: 1.0
		public void GetMaterial(MaterialFace face, MaterialParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetMaterialfv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialfv);
		}

		/// glGetMaterialiv
		/// Version: 1.0
		public void GetMaterial(uint face, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetMaterialiv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialiv);
		}

		/// glGetMaterialiv
		/// Version: 1.0
		public void GetMaterial(MaterialFace face, MaterialParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetMaterialiv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialiv);
		}

		/// glGetMaterialiv
		/// Version: 1.0
		public void GetMaterial(MaterialFace face, MaterialParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetMaterialiv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialiv);
		}

		/// glGetMaterialiv
		/// Version: 1.0
		public void GetMaterial(uint face, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMaterialiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetMaterialiv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMaterialiv);
		}

		private GLNative.GetMultisamplefv _GetMultisamplefv;

		/// glGetMultisamplefv
		/// Version: 3.2
		public void GetMultisample(uint pname, uint index, float[] val)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMultisamplefv);

			unsafe
			{
				fixed (float* valPtr = val)
				{
					if (this._GetMultisamplefv == null)
						this._GetMultisamplefv = (GLNative.GetMultisamplefv)this.LoadExtensionFunction<GLNative.GetMultisamplefv>();

					this._GetMultisamplefv(pname, index, valPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMultisamplefv);
		}

		/// glGetMultisamplefv
		/// Version: 3.2
		public void GetMultisample(uint pname, uint index, out float val)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetMultisamplefv);

			unsafe
			{
				fixed (float* valPtr = &val)
				{
					if (this._GetMultisamplefv == null)
						this._GetMultisamplefv = (GLNative.GetMultisamplefv)this.LoadExtensionFunction<GLNative.GetMultisamplefv>();

					this._GetMultisamplefv(pname, index, valPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetMultisamplefv);
		}

		/// glGetPixelMapfv
		/// Version: 1.0
		public void GetPixelMap(uint map, float[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = values)
				{
					GLNative.GetPixelMapfv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);
		}

		/// glGetPixelMapfv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, float[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = values)
				{
					GLNative.GetPixelMapfv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);
		}

		/// glGetPixelMapfv
		/// Version: 1.0
		public void GetPixelMap(uint map, out float values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = &values)
				{
					GLNative.GetPixelMapfv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);
		}

		/// glGetPixelMapfv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, out float values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = &values)
				{
					GLNative.GetPixelMapfv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapfv);
		}

		/// glGetPixelMapuiv
		/// Version: 1.0
		public void GetPixelMap(uint map, uint[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = values)
				{
					GLNative.GetPixelMapuiv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);
		}

		/// glGetPixelMapuiv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, uint[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = values)
				{
					GLNative.GetPixelMapuiv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);
		}

		/// glGetPixelMapuiv
		/// Version: 1.0
		public void GetPixelMap(uint map, out uint values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = &values)
				{
					GLNative.GetPixelMapuiv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);
		}

		/// glGetPixelMapuiv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, out uint values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = &values)
				{
					GLNative.GetPixelMapuiv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapuiv);
		}

		/// glGetPixelMapusv
		/// Version: 1.0
		public void GetPixelMap(uint map, ushort[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = values)
				{
					GLNative.GetPixelMapusv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);
		}

		/// glGetPixelMapusv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, out ushort values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = &values)
				{
					GLNative.GetPixelMapusv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);
		}

		/// glGetPixelMapusv
		/// Version: 1.0
		public void GetPixelMap(PixelMap map, ushort[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = values)
				{
					GLNative.GetPixelMapusv((uint)map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);
		}

		/// glGetPixelMapusv
		/// Version: 1.0
		public void GetPixelMap(uint map, out ushort values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = &values)
				{
					GLNative.GetPixelMapusv(map, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPixelMapusv);
		}

		/// glGetPointerv
		/// Version: 1.1
		public void GetPointer(GetPointervPName pname, IntPtr @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPointerv);

			unsafe
			{
				GLNative.GetPointerv((uint)pname, @params);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPointerv);
		}

		/// glGetPointerv
		/// Version: 1.1
		public void GetPointer(uint pname, out IntPtr @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPointerv);

			@params = default(IntPtr);

			unsafe
			{
				GLNative.GetPointerv(pname, @params);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPointerv);
		}

		/// glGetPolygonStipple
		/// Version: 1.0
		public void GetPolygonStipple(byte[] mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPolygonStipple);

			unsafe
			{
				fixed (byte* maskPtr = mask)
				{
					GLNative.GetPolygonStipple(maskPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPolygonStipple);
		}

		/// glGetPolygonStipple
		/// Version: 1.0
		public void GetPolygonStipple(out byte mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetPolygonStipple);

			unsafe
			{
				fixed (byte* maskPtr = &mask)
				{
					GLNative.GetPolygonStipple(maskPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetPolygonStipple);
		}

		/// glGetProgramInfoLog
		/// Version: 2.0
		public void GetProgramInfoLog(uint program, int bufSize, out int length, StringBuilder infoLog)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetProgramInfoLog);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._GetProgramInfoLog == null)
						this._GetProgramInfoLog = (GLNative.GetProgramInfoLog)this.LoadExtensionFunction<GLNative.GetProgramInfoLog>();

					this._GetProgramInfoLog(program, bufSize, lengthPtr, infoLog);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetProgramInfoLog);
		}

		private GLNative.GetProgramInfoLog _GetProgramInfoLog;

		/// glGetProgramInfoLog
		/// Version: 2.0
		public void GetProgramInfoLog(uint program, int bufSize, int[] length, StringBuilder infoLog)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetProgramInfoLog);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._GetProgramInfoLog == null)
						this._GetProgramInfoLog = (GLNative.GetProgramInfoLog)this.LoadExtensionFunction<GLNative.GetProgramInfoLog>();

					this._GetProgramInfoLog(program, bufSize, lengthPtr, infoLog);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetProgramInfoLog);
		}

		/// glGetProgramiv
		/// Version: 2.0
		public void GetProgram(uint program, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetProgramiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetProgramiv == null)
						this._GetProgramiv = (GLNative.GetProgramiv)this.LoadExtensionFunction<GLNative.GetProgramiv>();

					this._GetProgramiv(program, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetProgramiv);
		}

		private GLNative.GetProgramiv _GetProgramiv;

		/// glGetProgramiv
		/// Version: 2.0
		public void GetProgram(uint program, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetProgramiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetProgramiv == null)
						this._GetProgramiv = (GLNative.GetProgramiv)this.LoadExtensionFunction<GLNative.GetProgramiv>();

					this._GetProgramiv(program, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetProgramiv);
		}

		/// glGetQueryiv
		/// Version: 1.5
		public void GetQuery(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetQueryiv == null)
						this._GetQueryiv = (GLNative.GetQueryiv)this.LoadExtensionFunction<GLNative.GetQueryiv>();

					this._GetQueryiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryiv);
		}

		private GLNative.GetQueryiv _GetQueryiv;

		/// glGetQueryiv
		/// Version: 1.5
		public void GetQuery(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetQueryiv == null)
						this._GetQueryiv = (GLNative.GetQueryiv)this.LoadExtensionFunction<GLNative.GetQueryiv>();

					this._GetQueryiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryiv);
		}

		private GLNative.GetQueryObjecti64v _GetQueryObjecti64v;

		/// glGetQueryObjecti64v
		/// Version: 3.3
		public void GetQueryObjecti64(uint id, uint pname, long[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjecti64v);

			unsafe
			{
				fixed (long* @paramsPtr = @params)
				{
					if (this._GetQueryObjecti64v == null)
						this._GetQueryObjecti64v = (GLNative.GetQueryObjecti64v)this.LoadExtensionFunction<GLNative.GetQueryObjecti64v>();

					this._GetQueryObjecti64v(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjecti64v);
		}

		/// glGetQueryObjecti64v
		/// Version: 3.3
		public void GetQueryObjecti64(uint id, uint pname, out long @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjecti64v);

			unsafe
			{
				fixed (long* @paramsPtr = &@params)
				{
					if (this._GetQueryObjecti64v == null)
						this._GetQueryObjecti64v = (GLNative.GetQueryObjecti64v)this.LoadExtensionFunction<GLNative.GetQueryObjecti64v>();

					this._GetQueryObjecti64v(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjecti64v);
		}

		private GLNative.GetQueryObjectiv _GetQueryObjectiv;

		/// glGetQueryObjectiv
		/// Version: 1.5
		public void GetQueryObject(uint id, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetQueryObjectiv == null)
						this._GetQueryObjectiv = (GLNative.GetQueryObjectiv)this.LoadExtensionFunction<GLNative.GetQueryObjectiv>();

					this._GetQueryObjectiv(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectiv);
		}

		/// glGetQueryObjectiv
		/// Version: 1.5
		public void GetQueryObject(uint id, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetQueryObjectiv == null)
						this._GetQueryObjectiv = (GLNative.GetQueryObjectiv)this.LoadExtensionFunction<GLNative.GetQueryObjectiv>();

					this._GetQueryObjectiv(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectiv);
		}

		/// glGetQueryObjectui64v
		/// Version: 3.3
		public void GetQueryObjectui64(uint id, uint pname, out ulong @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectui64v);

			unsafe
			{
				fixed (ulong* @paramsPtr = &@params)
				{
					if (this._GetQueryObjectui64v == null)
						this._GetQueryObjectui64v = (GLNative.GetQueryObjectui64v)this.LoadExtensionFunction<GLNative.GetQueryObjectui64v>();

					this._GetQueryObjectui64v(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectui64v);
		}

		private GLNative.GetQueryObjectui64v _GetQueryObjectui64v;

		/// glGetQueryObjectui64v
		/// Version: 3.3
		public void GetQueryObjectui64(uint id, uint pname, ulong[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectui64v);

			unsafe
			{
				fixed (ulong* @paramsPtr = @params)
				{
					if (this._GetQueryObjectui64v == null)
						this._GetQueryObjectui64v = (GLNative.GetQueryObjectui64v)this.LoadExtensionFunction<GLNative.GetQueryObjectui64v>();

					this._GetQueryObjectui64v(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectui64v);
		}

		private GLNative.GetQueryObjectuiv _GetQueryObjectuiv;

		/// glGetQueryObjectuiv
		/// Version: 1.5
		public void GetQueryObject(uint id, uint pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetQueryObjectuiv == null)
						this._GetQueryObjectuiv = (GLNative.GetQueryObjectuiv)this.LoadExtensionFunction<GLNative.GetQueryObjectuiv>();

					this._GetQueryObjectuiv(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectuiv);
		}

		/// glGetQueryObjectuiv
		/// Version: 1.5
		public void GetQueryObject(uint id, uint pname, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetQueryObjectuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetQueryObjectuiv == null)
						this._GetQueryObjectuiv = (GLNative.GetQueryObjectuiv)this.LoadExtensionFunction<GLNative.GetQueryObjectuiv>();

					this._GetQueryObjectuiv(id, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetQueryObjectuiv);
		}

		private GLNative.GetRenderbufferParameteriv _GetRenderbufferParameteriv;

		/// glGetRenderbufferParameteriv
		/// Version: 3.0
		public void GetRenderbufferParameter(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetRenderbufferParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetRenderbufferParameteriv == null)
						this._GetRenderbufferParameteriv = (GLNative.GetRenderbufferParameteriv)this.LoadExtensionFunction<GLNative.GetRenderbufferParameteriv>();

					this._GetRenderbufferParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetRenderbufferParameteriv);
		}

		/// glGetRenderbufferParameteriv
		/// Version: 3.0
		public void GetRenderbufferParameter(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetRenderbufferParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetRenderbufferParameteriv == null)
						this._GetRenderbufferParameteriv = (GLNative.GetRenderbufferParameteriv)this.LoadExtensionFunction<GLNative.GetRenderbufferParameteriv>();

					this._GetRenderbufferParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetRenderbufferParameteriv);
		}

		private GLNative.GetSamplerParameterfv _GetSamplerParameterfv;

		/// glGetSamplerParameterfv
		/// Version: 3.3
		public void GetSamplerParameter(uint sampler, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					if (this._GetSamplerParameterfv == null)
						this._GetSamplerParameterfv = (GLNative.GetSamplerParameterfv)this.LoadExtensionFunction<GLNative.GetSamplerParameterfv>();

					this._GetSamplerParameterfv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterfv);
		}

		/// glGetSamplerParameterfv
		/// Version: 3.3
		public void GetSamplerParameter(uint sampler, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					if (this._GetSamplerParameterfv == null)
						this._GetSamplerParameterfv = (GLNative.GetSamplerParameterfv)this.LoadExtensionFunction<GLNative.GetSamplerParameterfv>();

					this._GetSamplerParameterfv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterfv);
		}

		private GLNative.GetSamplerParameterIiv _GetSamplerParameterIiv;

		/// glGetSamplerParameterIiv
		/// Version: 3.3
		public void GetSamplerParameterI(uint sampler, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetSamplerParameterIiv == null)
						this._GetSamplerParameterIiv = (GLNative.GetSamplerParameterIiv)this.LoadExtensionFunction<GLNative.GetSamplerParameterIiv>();

					this._GetSamplerParameterIiv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIiv);
		}

		/// glGetSamplerParameterIiv
		/// Version: 3.3
		public void GetSamplerParameterI(uint sampler, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetSamplerParameterIiv == null)
						this._GetSamplerParameterIiv = (GLNative.GetSamplerParameterIiv)this.LoadExtensionFunction<GLNative.GetSamplerParameterIiv>();

					this._GetSamplerParameterIiv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIiv);
		}

		private GLNative.GetSamplerParameterIuiv _GetSamplerParameterIuiv;

		/// glGetSamplerParameterIuiv
		/// Version: 3.3
		public void GetSamplerParameterI(uint sampler, uint pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetSamplerParameterIuiv == null)
						this._GetSamplerParameterIuiv = (GLNative.GetSamplerParameterIuiv)this.LoadExtensionFunction<GLNative.GetSamplerParameterIuiv>();

					this._GetSamplerParameterIuiv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIuiv);
		}

		/// glGetSamplerParameterIuiv
		/// Version: 3.3
		public void GetSamplerParameterI(uint sampler, uint pname, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetSamplerParameterIuiv == null)
						this._GetSamplerParameterIuiv = (GLNative.GetSamplerParameterIuiv)this.LoadExtensionFunction<GLNative.GetSamplerParameterIuiv>();

					this._GetSamplerParameterIuiv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameterIuiv);
		}

		/// glGetSamplerParameteriv
		/// Version: 3.3
		public void GetSamplerParameter(uint sampler, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetSamplerParameteriv == null)
						this._GetSamplerParameteriv = (GLNative.GetSamplerParameteriv)this.LoadExtensionFunction<GLNative.GetSamplerParameteriv>();

					this._GetSamplerParameteriv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameteriv);
		}

		private GLNative.GetSamplerParameteriv _GetSamplerParameteriv;

		/// glGetSamplerParameteriv
		/// Version: 3.3
		public void GetSamplerParameter(uint sampler, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSamplerParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetSamplerParameteriv == null)
						this._GetSamplerParameteriv = (GLNative.GetSamplerParameteriv)this.LoadExtensionFunction<GLNative.GetSamplerParameteriv>();

					this._GetSamplerParameteriv(sampler, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSamplerParameteriv);
		}

		/// glGetShaderInfoLog
		/// Version: 2.0
		public void GetShaderInfoLog(uint shader, int bufSize, out int length, StringBuilder infoLog)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderInfoLog);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._GetShaderInfoLog == null)
						this._GetShaderInfoLog = (GLNative.GetShaderInfoLog)this.LoadExtensionFunction<GLNative.GetShaderInfoLog>();

					this._GetShaderInfoLog(shader, bufSize, lengthPtr, infoLog);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderInfoLog);
		}

		private GLNative.GetShaderInfoLog _GetShaderInfoLog;

		/// glGetShaderInfoLog
		/// Version: 2.0
		public void GetShaderInfoLog(uint shader, int bufSize, int[] length, StringBuilder infoLog)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderInfoLog);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._GetShaderInfoLog == null)
						this._GetShaderInfoLog = (GLNative.GetShaderInfoLog)this.LoadExtensionFunction<GLNative.GetShaderInfoLog>();

					this._GetShaderInfoLog(shader, bufSize, lengthPtr, infoLog);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderInfoLog);
		}

		private GLNative.GetShaderiv _GetShaderiv;

		/// glGetShaderiv
		/// Version: 2.0
		public void GetShader(uint shader, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetShaderiv == null)
						this._GetShaderiv = (GLNative.GetShaderiv)this.LoadExtensionFunction<GLNative.GetShaderiv>();

					this._GetShaderiv(shader, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderiv);
		}

		/// glGetShaderiv
		/// Version: 2.0
		public void GetShader(uint shader, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetShaderiv == null)
						this._GetShaderiv = (GLNative.GetShaderiv)this.LoadExtensionFunction<GLNative.GetShaderiv>();

					this._GetShaderiv(shader, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderiv);
		}

		/// glGetShaderSource
		/// Version: 2.0
		public void GetShaderSource(uint shader, int bufSize, out int length, StringBuilder source)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderSource);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._GetShaderSource == null)
						this._GetShaderSource = (GLNative.GetShaderSource)this.LoadExtensionFunction<GLNative.GetShaderSource>();

					this._GetShaderSource(shader, bufSize, lengthPtr, source);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderSource);
		}

		private GLNative.GetShaderSource _GetShaderSource;

		/// glGetShaderSource
		/// Version: 2.0
		public void GetShaderSource(uint shader, int bufSize, int[] length, StringBuilder source)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetShaderSource);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._GetShaderSource == null)
						this._GetShaderSource = (GLNative.GetShaderSource)this.LoadExtensionFunction<GLNative.GetShaderSource>();

					this._GetShaderSource(shader, bufSize, lengthPtr, source);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetShaderSource);
		}

		/// glGetString
		/// Version: 1.0
		public byte GetString(uint name)
		{
			byte result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetString);

			result = GLNative.GetString(name);

			this.AfterNativeFunctionCall(GLNativeFunctions.GetString);

			return result;
		}

		/// glGetString
		/// Version: 1.0
		public byte GetString(StringName name)
		{
			byte result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetString);

			result = GLNative.GetString((uint)name);

			this.AfterNativeFunctionCall(GLNativeFunctions.GetString);

			return result;
		}

		private GLNative.GetStringi _GetStringi;

		/// glGetStringi
		/// Version: 3.0
		public byte GetString(uint name, uint index)
		{
			byte result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetStringi);

			if (this._GetStringi == null)
				this._GetStringi = (GLNative.GetStringi)this.LoadExtensionFunction<GLNative.GetStringi>();

			result = this._GetStringi(name, index);

			this.AfterNativeFunctionCall(GLNativeFunctions.GetStringi);

			return result;
		}

		/// glGetSynciv
		/// Version: 3.2
		public void GetSync(IntPtr sync, uint pname, int bufSize, out int length, out int values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSynciv);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				fixed (int* valuesPtr = &values)
				{
					if (this._GetSynciv == null)
						this._GetSynciv = (GLNative.GetSynciv)this.LoadExtensionFunction<GLNative.GetSynciv>();

					this._GetSynciv(sync, pname, bufSize, lengthPtr, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSynciv);
		}

		private GLNative.GetSynciv _GetSynciv;

		/// glGetSynciv
		/// Version: 3.2
		public void GetSync(IntPtr sync, uint pname, int bufSize, int[] length, int[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetSynciv);

			unsafe
			{
				fixed (int* lengthPtr = length)
				fixed (int* valuesPtr = values)
				{
					if (this._GetSynciv == null)
						this._GetSynciv = (GLNative.GetSynciv)this.LoadExtensionFunction<GLNative.GetSynciv>();

					this._GetSynciv(sync, pname, bufSize, lengthPtr, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetSynciv);
		}

		/// glGetTexEnvfv
		/// Version: 1.0
		public void GetTexEnv(uint target, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexEnvfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);
		}

		/// glGetTexEnvfv
		/// Version: 1.0
		public void GetTexEnv(uint target, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexEnvfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);
		}

		/// glGetTexEnvfv
		/// Version: 1.0
		public void GetTexEnv(TextureEnvTarget target, TextureEnvParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexEnvfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);
		}

		/// glGetTexEnvfv
		/// Version: 1.0
		public void GetTexEnv(TextureEnvTarget target, TextureEnvParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexEnvfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnvfv);
		}

		/// glGetTexEnviv
		/// Version: 1.0
		public void GetTexEnv(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexEnviv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnviv);
		}

		/// glGetTexEnviv
		/// Version: 1.0
		public void GetTexEnv(TextureEnvTarget target, TextureEnvParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexEnviv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnviv);
		}

		/// glGetTexEnviv
		/// Version: 1.0
		public void GetTexEnv(TextureEnvTarget target, TextureEnvParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexEnviv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnviv);
		}

		/// glGetTexEnviv
		/// Version: 1.0
		public void GetTexEnv(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexEnviv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexEnviv);
		}

		/// glGetTexGendv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, out double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.GetTexGendv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGendv);
		}

		/// glGetTexGendv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, out double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.GetTexGendv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGendv);
		}

		/// glGetTexGendv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.GetTexGendv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGendv);
		}

		/// glGetTexGendv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.GetTexGendv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGendv);
		}

		/// glGetTexGenfv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexGenfv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGenfv);
		}

		/// glGetTexGenfv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexGenfv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGenfv);
		}

		/// glGetTexGenfv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexGenfv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGenfv);
		}

		/// glGetTexGenfv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexGenfv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGenfv);
		}

		/// glGetTexGeniv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexGeniv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGeniv);
		}

		/// glGetTexGeniv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexGeniv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGeniv);
		}

		/// glGetTexGeniv
		/// Version: 1.0
		public void GetTexGen(TextureCoordName coord, TextureGenParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexGeniv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGeniv);
		}

		/// glGetTexGeniv
		/// Version: 1.0
		public void GetTexGen(uint coord, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexGeniv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexGeniv);
		}

		/// glGetTexImage
		/// Version: 1.0
		public void GetTexImage<T>(uint target, int level, uint format, uint type, out IntPtr pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexImage);

			pixels = default(IntPtr);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.GetTexImage(target, level, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexImage);
		}

		/// glGetTexImage
		/// Version: 1.0
		public void GetTexImage<T>(TextureTarget target, int level, PixelFormat format, PixelType type, IntPtr pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexImage);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.GetTexImage((uint)target, level, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexImage);
		}

		/// glGetTexLevelParameterfv
		/// Version: 1.0
		public void GetTexLevelParameter(TextureTarget target, int level, GetTextureParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexLevelParameterfv((uint)target, level, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);
		}

		/// glGetTexLevelParameterfv
		/// Version: 1.0
		public void GetTexLevelParameter(uint target, int level, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexLevelParameterfv(target, level, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);
		}

		/// glGetTexLevelParameterfv
		/// Version: 1.0
		public void GetTexLevelParameter(uint target, int level, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexLevelParameterfv(target, level, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);
		}

		/// glGetTexLevelParameterfv
		/// Version: 1.0
		public void GetTexLevelParameter(TextureTarget target, int level, GetTextureParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexLevelParameterfv((uint)target, level, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameterfv);
		}

		/// glGetTexLevelParameteriv
		/// Version: 1.0
		public void GetTexLevelParameter(uint target, int level, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexLevelParameteriv(target, level, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);
		}

		/// glGetTexLevelParameteriv
		/// Version: 1.0
		public void GetTexLevelParameter(TextureTarget target, int level, GetTextureParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexLevelParameteriv((uint)target, level, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);
		}

		/// glGetTexLevelParameteriv
		/// Version: 1.0
		public void GetTexLevelParameter(TextureTarget target, int level, GetTextureParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexLevelParameteriv((uint)target, level, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);
		}

		/// glGetTexLevelParameteriv
		/// Version: 1.0
		public void GetTexLevelParameter(uint target, int level, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexLevelParameteriv(target, level, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexLevelParameteriv);
		}

		/// glGetTexParameterfv
		/// Version: 1.0
		public void GetTexParameter(uint target, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexParameterfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);
		}

		/// glGetTexParameterfv
		/// Version: 1.0
		public void GetTexParameter(TextureTarget target, GetTextureParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.GetTexParameterfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);
		}

		/// glGetTexParameterfv
		/// Version: 1.0
		public void GetTexParameter(uint target, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexParameterfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);
		}

		/// glGetTexParameterfv
		/// Version: 1.0
		public void GetTexParameter(TextureTarget target, GetTextureParameter pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.GetTexParameterfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterfv);
		}

		/// glGetTexParameterIiv
		/// Version: 3.0
		public void GetTexParameterI(TextureTarget target, GetTextureParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetTexParameterIiv == null)
						this._GetTexParameterIiv = (GLNative.GetTexParameterIiv)this.LoadExtensionFunction<GLNative.GetTexParameterIiv>();

					this._GetTexParameterIiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);
		}

		/// glGetTexParameterIiv
		/// Version: 3.0
		public void GetTexParameterI(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetTexParameterIiv == null)
						this._GetTexParameterIiv = (GLNative.GetTexParameterIiv)this.LoadExtensionFunction<GLNative.GetTexParameterIiv>();

					this._GetTexParameterIiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);
		}

		private GLNative.GetTexParameterIiv _GetTexParameterIiv;

		/// glGetTexParameterIiv
		/// Version: 3.0
		public void GetTexParameterI(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetTexParameterIiv == null)
						this._GetTexParameterIiv = (GLNative.GetTexParameterIiv)this.LoadExtensionFunction<GLNative.GetTexParameterIiv>();

					this._GetTexParameterIiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);
		}

		/// glGetTexParameterIiv
		/// Version: 3.0
		public void GetTexParameterI(TextureTarget target, GetTextureParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetTexParameterIiv == null)
						this._GetTexParameterIiv = (GLNative.GetTexParameterIiv)this.LoadExtensionFunction<GLNative.GetTexParameterIiv>();

					this._GetTexParameterIiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIiv);
		}

		/// glGetTexParameterIuiv
		/// Version: 3.0
		public void GetTexParameterI(TextureTarget target, GetTextureParameter pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetTexParameterIuiv == null)
						this._GetTexParameterIuiv = (GLNative.GetTexParameterIuiv)this.LoadExtensionFunction<GLNative.GetTexParameterIuiv>();

					this._GetTexParameterIuiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);
		}

		/// glGetTexParameterIuiv
		/// Version: 3.0
		public void GetTexParameterI(TextureTarget target, GetTextureParameter pname, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetTexParameterIuiv == null)
						this._GetTexParameterIuiv = (GLNative.GetTexParameterIuiv)this.LoadExtensionFunction<GLNative.GetTexParameterIuiv>();

					this._GetTexParameterIuiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);
		}

		private GLNative.GetTexParameterIuiv _GetTexParameterIuiv;

		/// glGetTexParameterIuiv
		/// Version: 3.0
		public void GetTexParameterI(uint target, uint pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetTexParameterIuiv == null)
						this._GetTexParameterIuiv = (GLNative.GetTexParameterIuiv)this.LoadExtensionFunction<GLNative.GetTexParameterIuiv>();

					this._GetTexParameterIuiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);
		}

		/// glGetTexParameterIuiv
		/// Version: 3.0
		public void GetTexParameterI(uint target, uint pname, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetTexParameterIuiv == null)
						this._GetTexParameterIuiv = (GLNative.GetTexParameterIuiv)this.LoadExtensionFunction<GLNative.GetTexParameterIuiv>();

					this._GetTexParameterIuiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameterIuiv);
		}

		/// glGetTexParameteriv
		/// Version: 1.0
		public void GetTexParameter(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);
		}

		/// glGetTexParameteriv
		/// Version: 1.0
		public void GetTexParameter(uint target, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);
		}

		/// glGetTexParameteriv
		/// Version: 1.0
		public void GetTexParameter(TextureTarget target, GetTextureParameter pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.GetTexParameteriv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);
		}

		/// glGetTexParameteriv
		/// Version: 1.0
		public void GetTexParameter(TextureTarget target, GetTextureParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.GetTexParameteriv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTexParameteriv);
		}

		private GLNative.GetTransformFeedbackVarying _GetTransformFeedbackVarying;

		/// glGetTransformFeedbackVarying
		/// Version: 3.0
		public void GetTransformFeedbackVarying(uint program, uint index, int bufSize, int[] length, int[] size, uint[] type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTransformFeedbackVarying);

			unsafe
			{
				fixed (int* lengthPtr = length)
				fixed (int* sizePtr = size)
				fixed (uint* typePtr = type)
				{
					if (this._GetTransformFeedbackVarying == null)
						this._GetTransformFeedbackVarying = (GLNative.GetTransformFeedbackVarying)this.LoadExtensionFunction<GLNative.GetTransformFeedbackVarying>();

					this._GetTransformFeedbackVarying(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTransformFeedbackVarying);
		}

		/// glGetTransformFeedbackVarying
		/// Version: 3.0
		public void GetTransformFeedbackVarying(uint program, uint index, int bufSize, out int length, out int size, out uint type, StringBuilder name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetTransformFeedbackVarying);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				fixed (int* sizePtr = &size)
				fixed (uint* typePtr = &type)
				{
					if (this._GetTransformFeedbackVarying == null)
						this._GetTransformFeedbackVarying = (GLNative.GetTransformFeedbackVarying)this.LoadExtensionFunction<GLNative.GetTransformFeedbackVarying>();

					this._GetTransformFeedbackVarying(program, index, bufSize, lengthPtr, sizePtr, typePtr, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetTransformFeedbackVarying);
		}

		private GLNative.GetUniformBlockIndex _GetUniformBlockIndex;

		/// glGetUniformBlockIndex
		/// Version: 3.1
		public uint GetUniformBlockIndex(uint program, string uniformBlockName)
		{
			uint result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformBlockIndex);

			unsafe
			{
				{
					if (this._GetUniformBlockIndex == null)
						this._GetUniformBlockIndex = (GLNative.GetUniformBlockIndex)this.LoadExtensionFunction<GLNative.GetUniformBlockIndex>();

					result = this._GetUniformBlockIndex(program, uniformBlockName);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformBlockIndex);

			return result;
		}

		/// glGetUniformfv
		/// Version: 2.0
		public void GetUniform(uint program, int location, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					if (this._GetUniformfv == null)
						this._GetUniformfv = (GLNative.GetUniformfv)this.LoadExtensionFunction<GLNative.GetUniformfv>();

					this._GetUniformfv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformfv);
		}

		private GLNative.GetUniformfv _GetUniformfv;

		/// glGetUniformfv
		/// Version: 2.0
		public void GetUniform(uint program, int location, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					if (this._GetUniformfv == null)
						this._GetUniformfv = (GLNative.GetUniformfv)this.LoadExtensionFunction<GLNative.GetUniformfv>();

					this._GetUniformfv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformfv);
		}

		/// glGetUniformIndices
		/// Version: 3.1
		public void GetUniformIndices(uint program, int uniformCount, string[] uniformNames, out uint uniformIndices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformIndices);

			unsafe
			{
				fixed (uint* uniformIndicesPtr = &uniformIndices)
				{
					if (this._GetUniformIndices == null)
						this._GetUniformIndices = (GLNative.GetUniformIndices)this.LoadExtensionFunction<GLNative.GetUniformIndices>();

					this._GetUniformIndices(program, uniformCount, uniformNames, uniformIndicesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformIndices);
		}

		private GLNative.GetUniformIndices _GetUniformIndices;

		/// glGetUniformIndices
		/// Version: 3.1
		public void GetUniformIndices(uint program, int uniformCount, string[] uniformNames, uint[] uniformIndices)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformIndices);

			unsafe
			{
				fixed (uint* uniformIndicesPtr = uniformIndices)
				{
					if (this._GetUniformIndices == null)
						this._GetUniformIndices = (GLNative.GetUniformIndices)this.LoadExtensionFunction<GLNative.GetUniformIndices>();

					this._GetUniformIndices(program, uniformCount, uniformNames, uniformIndicesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformIndices);
		}

		private GLNative.GetUniformiv _GetUniformiv;

		/// glGetUniformiv
		/// Version: 2.0
		public void GetUniform(uint program, int location, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetUniformiv == null)
						this._GetUniformiv = (GLNative.GetUniformiv)this.LoadExtensionFunction<GLNative.GetUniformiv>();

					this._GetUniformiv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformiv);
		}

		/// glGetUniformiv
		/// Version: 2.0
		public void GetUniform(uint program, int location, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetUniformiv == null)
						this._GetUniformiv = (GLNative.GetUniformiv)this.LoadExtensionFunction<GLNative.GetUniformiv>();

					this._GetUniformiv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformiv);
		}

		private GLNative.GetUniformLocation _GetUniformLocation;

		/// glGetUniformLocation
		/// Version: 2.0
		public int GetUniformLocation(uint program, string name)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformLocation);

			unsafe
			{
				{
					if (this._GetUniformLocation == null)
						this._GetUniformLocation = (GLNative.GetUniformLocation)this.LoadExtensionFunction<GLNative.GetUniformLocation>();

					result = this._GetUniformLocation(program, name);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformLocation);

			return result;
		}

		private GLNative.GetUniformuiv _GetUniformuiv;

		/// glGetUniformuiv
		/// Version: 3.0
		public void GetUniform(uint program, int location, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetUniformuiv == null)
						this._GetUniformuiv = (GLNative.GetUniformuiv)this.LoadExtensionFunction<GLNative.GetUniformuiv>();

					this._GetUniformuiv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformuiv);
		}

		/// glGetUniformuiv
		/// Version: 3.0
		public void GetUniform(uint program, int location, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetUniformuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetUniformuiv == null)
						this._GetUniformuiv = (GLNative.GetUniformuiv)this.LoadExtensionFunction<GLNative.GetUniformuiv>();

					this._GetUniformuiv(program, location, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetUniformuiv);
		}

		/// glGetVertexAttribdv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, out double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribdv);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					if (this._GetVertexAttribdv == null)
						this._GetVertexAttribdv = (GLNative.GetVertexAttribdv)this.LoadExtensionFunction<GLNative.GetVertexAttribdv>();

					this._GetVertexAttribdv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribdv);
		}

		private GLNative.GetVertexAttribdv _GetVertexAttribdv;

		/// glGetVertexAttribdv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribdv);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					if (this._GetVertexAttribdv == null)
						this._GetVertexAttribdv = (GLNative.GetVertexAttribdv)this.LoadExtensionFunction<GLNative.GetVertexAttribdv>();

					this._GetVertexAttribdv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribdv);
		}

		private GLNative.GetVertexAttribfv _GetVertexAttribfv;

		/// glGetVertexAttribfv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					if (this._GetVertexAttribfv == null)
						this._GetVertexAttribfv = (GLNative.GetVertexAttribfv)this.LoadExtensionFunction<GLNative.GetVertexAttribfv>();

					this._GetVertexAttribfv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribfv);
		}

		/// glGetVertexAttribfv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, out float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					if (this._GetVertexAttribfv == null)
						this._GetVertexAttribfv = (GLNative.GetVertexAttribfv)this.LoadExtensionFunction<GLNative.GetVertexAttribfv>();

					this._GetVertexAttribfv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribfv);
		}

		/// glGetVertexAttribIiv
		/// Version: 3.0
		public void GetVertexAttribI(uint index, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetVertexAttribIiv == null)
						this._GetVertexAttribIiv = (GLNative.GetVertexAttribIiv)this.LoadExtensionFunction<GLNative.GetVertexAttribIiv>();

					this._GetVertexAttribIiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribIiv);
		}

		private GLNative.GetVertexAttribIiv _GetVertexAttribIiv;

		/// glGetVertexAttribIiv
		/// Version: 3.0
		public void GetVertexAttribI(uint index, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetVertexAttribIiv == null)
						this._GetVertexAttribIiv = (GLNative.GetVertexAttribIiv)this.LoadExtensionFunction<GLNative.GetVertexAttribIiv>();

					this._GetVertexAttribIiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribIiv);
		}

		private GLNative.GetVertexAttribIuiv _GetVertexAttribIuiv;

		/// glGetVertexAttribIuiv
		/// Version: 3.0
		public void GetVertexAttribI(uint index, uint pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._GetVertexAttribIuiv == null)
						this._GetVertexAttribIuiv = (GLNative.GetVertexAttribIuiv)this.LoadExtensionFunction<GLNative.GetVertexAttribIuiv>();

					this._GetVertexAttribIuiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribIuiv);
		}

		/// glGetVertexAttribIuiv
		/// Version: 3.0
		public void GetVertexAttribI(uint index, uint pname, out uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._GetVertexAttribIuiv == null)
						this._GetVertexAttribIuiv = (GLNative.GetVertexAttribIuiv)this.LoadExtensionFunction<GLNative.GetVertexAttribIuiv>();

					this._GetVertexAttribIuiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribIuiv);
		}

		/// glGetVertexAttribiv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, out int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._GetVertexAttribiv == null)
						this._GetVertexAttribiv = (GLNative.GetVertexAttribiv)this.LoadExtensionFunction<GLNative.GetVertexAttribiv>();

					this._GetVertexAttribiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribiv);
		}

		private GLNative.GetVertexAttribiv _GetVertexAttribiv;

		/// glGetVertexAttribiv
		/// Version: 2.0
		public void GetVertexAttrib(uint index, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._GetVertexAttribiv == null)
						this._GetVertexAttribiv = (GLNative.GetVertexAttribiv)this.LoadExtensionFunction<GLNative.GetVertexAttribiv>();

					this._GetVertexAttribiv(index, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribiv);
		}

		private GLNative.GetVertexAttribPointerv _GetVertexAttribPointerv;

		/// glGetVertexAttribPointerv
		/// Version: 2.0
		public void GetVertexAttribPointer(uint index, uint pname, out IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.GetVertexAttribPointerv);

			pointer = default(IntPtr);

			unsafe
			{
				if (this._GetVertexAttribPointerv == null)
					this._GetVertexAttribPointerv = (GLNative.GetVertexAttribPointerv)this.LoadExtensionFunction<GLNative.GetVertexAttribPointerv>();

				this._GetVertexAttribPointerv(index, pname, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.GetVertexAttribPointerv);
		}

		/// glHint
		/// Version: 1.0
		public void Hint(HintTarget target, HintMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Hint);

			GLNative.Hint((uint)target, (uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.Hint);
		}

		/// glHint
		/// Version: 1.0
		public void Hint(uint target, uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Hint);

			GLNative.Hint(target, mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.Hint);
		}

		/// glIndexd
		/// Version: 1.0
		public void Index(double c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexd);

			GLNative.Indexd(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexd);
		}

		/// glIndexdv
		/// Version: 1.0
		public void Index(double[] c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexdv);

			unsafe
			{
				fixed (double* cPtr = c)
				{
					GLNative.Indexdv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexdv);
		}

		/// glIndexdv
		/// Version: 1.0
		public void Index(ref double c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexdv);

			unsafe
			{
				fixed (double* cPtr = &c)
				{
					GLNative.Indexdv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexdv);
		}

		/// glIndexf
		/// Version: 1.0
		public void Index(float c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexf);

			GLNative.Indexf(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexf);
		}

		/// glIndexfv
		/// Version: 1.0
		public void Index(ref float c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexfv);

			unsafe
			{
				fixed (float* cPtr = &c)
				{
					GLNative.Indexfv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexfv);
		}

		/// glIndexfv
		/// Version: 1.0
		public void Index(float[] c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexfv);

			unsafe
			{
				fixed (float* cPtr = c)
				{
					GLNative.Indexfv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexfv);
		}

		/// glIndexi
		/// Version: 1.0
		public void Index(int c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexi);

			GLNative.Indexi(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexi);
		}

		/// glIndexiv
		/// Version: 1.0
		public void Index(int[] c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexiv);

			unsafe
			{
				fixed (int* cPtr = c)
				{
					GLNative.Indexiv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexiv);
		}

		/// glIndexiv
		/// Version: 1.0
		public void Index(ref int c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexiv);

			unsafe
			{
				fixed (int* cPtr = &c)
				{
					GLNative.Indexiv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexiv);
		}

		/// glIndexMask
		/// Version: 1.0
		public void IndexMask(uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexMask);

			GLNative.IndexMask(mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexMask);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer<T>(uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.IndexPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer<T>(IndexPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.IndexPointer((uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer(IndexPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GLNative.IndexPointer((uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer<T>(IndexPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.IndexPointer((uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer<T>(uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.IndexPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexPointer
		/// Version: 1.1
		public void IndexPointer(uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.IndexPointer);

			unsafe
			{
				GLNative.IndexPointer(type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.IndexPointer);
		}

		/// glIndexs
		/// Version: 1.0
		public void Index(short c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexs);

			GLNative.Indexs(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexs);
		}

		/// glIndexsv
		/// Version: 1.0
		public void Index(short[] c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexsv);

			unsafe
			{
				fixed (short* cPtr = c)
				{
					GLNative.Indexsv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexsv);
		}

		/// glIndexsv
		/// Version: 1.0
		public void Index(ref short c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexsv);

			unsafe
			{
				fixed (short* cPtr = &c)
				{
					GLNative.Indexsv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexsv);
		}

		/// glIndexub
		/// Version: 1.1
		public void Indexu(byte c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexub);

			GLNative.Indexub(c);

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexub);
		}

		/// glIndexubv
		/// Version: 1.1
		public void Index(byte[] c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexubv);

			unsafe
			{
				fixed (byte* cPtr = c)
				{
					GLNative.Indexubv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexubv);
		}

		/// glIndexubv
		/// Version: 1.1
		public void Index(ref byte c)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Indexubv);

			unsafe
			{
				fixed (byte* cPtr = &c)
				{
					GLNative.Indexubv(cPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Indexubv);
		}

		/// glInitNames
		/// Version: 1.0
		public void InitName()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InitNames);

			GLNative.InitNames();

			this.AfterNativeFunctionCall(GLNativeFunctions.InitNames);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays<T>(InterleavedArrayFormat format, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.InterleavedArrays((uint)format, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays(InterleavedArrayFormat format, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GLNative.InterleavedArrays((uint)format, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays<T>(uint format, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.InterleavedArrays(format, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays<T>(uint format, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.InterleavedArrays(format, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays(uint format, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GLNative.InterleavedArrays(format, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		/// glInterleavedArrays
		/// Version: 1.1
		public void InterleavedArrays<T>(InterleavedArrayFormat format, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.InterleavedArrays);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.InterleavedArrays((uint)format, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.InterleavedArrays);
		}

		private GLNative.IsBuffer _IsBuffer;

		/// glIsBuffer
		/// Version: 1.5
		public bool IsBuffer(uint buffer)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsBuffer);

			if (this._IsBuffer == null)
				this._IsBuffer = (GLNative.IsBuffer)this.LoadExtensionFunction<GLNative.IsBuffer>();

			result = this._IsBuffer(buffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsBuffer);

			return result;
		}

		/// glIsEnabled
		/// Version: 1.0
		public bool IsEnable(uint cap)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsEnabled);

			result = GLNative.IsEnabled(cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsEnabled);

			return result;
		}

		/// glIsEnabled
		/// Version: 1.0
		public bool IsEnable(EnableCap cap)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsEnabled);

			result = GLNative.IsEnabled((uint)cap);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsEnabled);

			return result;
		}

		private GLNative.IsEnabledi _IsEnabledi;

		/// glIsEnabledi
		/// Version: 3.0
		public bool IsEnabled(uint target, uint index)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsEnabledi);

			if (this._IsEnabledi == null)
				this._IsEnabledi = (GLNative.IsEnabledi)this.LoadExtensionFunction<GLNative.IsEnabledi>();

			result = this._IsEnabledi(target, index);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsEnabledi);

			return result;
		}

		private GLNative.IsFramebuffer _IsFramebuffer;

		/// glIsFramebuffer
		/// Version: 3.0
		public bool IsFramebuffer(uint framebuffer)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsFramebuffer);

			if (this._IsFramebuffer == null)
				this._IsFramebuffer = (GLNative.IsFramebuffer)this.LoadExtensionFunction<GLNative.IsFramebuffer>();

			result = this._IsFramebuffer(framebuffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsFramebuffer);

			return result;
		}

		/// glIsList
		/// Version: 1.0
		public bool IsList(uint list)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsList);

			result = GLNative.IsList(list);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsList);

			return result;
		}

		private GLNative.IsProgram _IsProgram;

		/// glIsProgram
		/// Version: 2.0
		public bool IsProgram(uint program)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsProgram);

			if (this._IsProgram == null)
				this._IsProgram = (GLNative.IsProgram)this.LoadExtensionFunction<GLNative.IsProgram>();

			result = this._IsProgram(program);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsProgram);

			return result;
		}

		private GLNative.IsQuery _IsQuery;

		/// glIsQuery
		/// Version: 1.5
		public bool IsQuery(uint id)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsQuery);

			if (this._IsQuery == null)
				this._IsQuery = (GLNative.IsQuery)this.LoadExtensionFunction<GLNative.IsQuery>();

			result = this._IsQuery(id);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsQuery);

			return result;
		}

		private GLNative.IsRenderbuffer _IsRenderbuffer;

		/// glIsRenderbuffer
		/// Version: 3.0
		public bool IsRenderbuffer(uint renderbuffer)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsRenderbuffer);

			if (this._IsRenderbuffer == null)
				this._IsRenderbuffer = (GLNative.IsRenderbuffer)this.LoadExtensionFunction<GLNative.IsRenderbuffer>();

			result = this._IsRenderbuffer(renderbuffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsRenderbuffer);

			return result;
		}

		private GLNative.IsSampler _IsSampler;

		/// glIsSampler
		/// Version: 3.3
		public bool IsSampler(uint sampler)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsSampler);

			if (this._IsSampler == null)
				this._IsSampler = (GLNative.IsSampler)this.LoadExtensionFunction<GLNative.IsSampler>();

			result = this._IsSampler(sampler);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsSampler);

			return result;
		}

		private GLNative.IsShader _IsShader;

		/// glIsShader
		/// Version: 2.0
		public bool IsShader(uint shader)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsShader);

			if (this._IsShader == null)
				this._IsShader = (GLNative.IsShader)this.LoadExtensionFunction<GLNative.IsShader>();

			result = this._IsShader(shader);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsShader);

			return result;
		}

		private GLNative.IsSync _IsSync;

		/// glIsSync
		/// Version: 3.2
		public bool IsSync(IntPtr sync)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsSync);

			if (this._IsSync == null)
				this._IsSync = (GLNative.IsSync)this.LoadExtensionFunction<GLNative.IsSync>();

			result = this._IsSync(sync);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsSync);

			return result;
		}

		/// glIsTexture
		/// Version: 1.1
		public bool IsTexture(uint texture)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsTexture);

			result = GLNative.IsTexture(texture);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsTexture);

			return result;
		}

		private GLNative.IsVertexArray _IsVertexArray;

		/// glIsVertexArray
		/// Version: 3.0
		public bool IsVertexArray(uint array)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.IsVertexArray);

			if (this._IsVertexArray == null)
				this._IsVertexArray = (GLNative.IsVertexArray)this.LoadExtensionFunction<GLNative.IsVertexArray>();

			result = this._IsVertexArray(array);

			this.AfterNativeFunctionCall(GLNativeFunctions.IsVertexArray);

			return result;
		}

		/// glLightf
		/// Version: 1.0
		public void Light(uint light, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightf);

			GLNative.Lightf(light, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightf);
		}

		/// glLightf
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightf);

			GLNative.Lightf((uint)light, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightf);
		}

		/// glLightfv
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Lightfv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightfv);
		}

		/// glLightfv
		/// Version: 1.0
		public void Light(uint light, uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Lightfv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightfv);
		}

		/// glLightfv
		/// Version: 1.0
		public void Light(uint light, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Lightfv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightfv);
		}

		/// glLightfv
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Lightfv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightfv);
		}

		/// glLighti
		/// Version: 1.0
		public void Light(uint light, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lighti);

			GLNative.Lighti(light, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Lighti);
		}

		/// glLighti
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lighti);

			GLNative.Lighti((uint)light, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Lighti);
		}

		/// glLightiv
		/// Version: 1.0
		public void Light(uint light, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Lightiv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightiv);
		}

		/// glLightiv
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Lightiv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightiv);
		}

		/// glLightiv
		/// Version: 1.0
		public void Light(uint light, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Lightiv(light, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightiv);
		}

		/// glLightiv
		/// Version: 1.0
		public void Light(LightName light, LightParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Lightiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Lightiv((uint)light, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Lightiv);
		}

		/// glLightModelf
		/// Version: 1.0
		public void LightModel(uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelf);

			GLNative.LightModelf(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelf);
		}

		/// glLightModelf
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelf);

			GLNative.LightModelf((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelf);
		}

		/// glLightModelfv
		/// Version: 1.0
		public void LightModel(uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.LightModelfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelfv);
		}

		/// glLightModelfv
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.LightModelfv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelfv);
		}

		/// glLightModelfv
		/// Version: 1.0
		public void LightModel(uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.LightModelfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelfv);
		}

		/// glLightModelfv
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModelfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.LightModelfv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModelfv);
		}

		/// glLightModeli
		/// Version: 1.0
		public void LightModel(uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeli);

			GLNative.LightModeli(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeli);
		}

		/// glLightModeli
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeli);

			GLNative.LightModeli((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeli);
		}

		/// glLightModeliv
		/// Version: 1.0
		public void LightModel(uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeliv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.LightModeliv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeliv);
		}

		/// glLightModeliv
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeliv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.LightModeliv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeliv);
		}

		/// glLightModeliv
		/// Version: 1.0
		public void LightModel(uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeliv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.LightModeliv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeliv);
		}

		/// glLightModeliv
		/// Version: 1.0
		public void LightModel(LightModelParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LightModeliv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.LightModeliv((uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LightModeliv);
		}

		/// glLineStipple
		/// Version: 1.0
		public void LineStipple(int factor, ushort pattern)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LineStipple);

			GLNative.LineStipple(factor, pattern);

			this.AfterNativeFunctionCall(GLNativeFunctions.LineStipple);
		}

		/// glLineWidth
		/// Version: 1.0
		public void LineWidth(float width)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LineWidth);

			GLNative.LineWidth(width);

			this.AfterNativeFunctionCall(GLNativeFunctions.LineWidth);
		}

		private GLNative.LinkProgram _LinkProgram;

		/// glLinkProgram
		/// Version: 2.0
		public void LinkProgram(uint program)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LinkProgram);

			if (this._LinkProgram == null)
				this._LinkProgram = (GLNative.LinkProgram)this.LoadExtensionFunction<GLNative.LinkProgram>();

			this._LinkProgram(program);

			this.AfterNativeFunctionCall(GLNativeFunctions.LinkProgram);
		}

		/// glListBase
		/// Version: 1.0
		public void ListBase(uint @base)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ListBase);

			GLNative.ListBase(@base);

			this.AfterNativeFunctionCall(GLNativeFunctions.ListBase);
		}

		/// glLoadIdentity
		/// Version: 1.0
		public void LoadIdentity()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadIdentity);

			GLNative.LoadIdentity();

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadIdentity);
		}

		/// glLoadMatrixd
		/// Version: 1.0
		public void LoadMatrix(ref double m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadMatrixd);

			unsafe
			{
				fixed (double* mPtr = &m)
				{
					GLNative.LoadMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadMatrixd);
		}

		/// glLoadMatrixd
		/// Version: 1.0
		public void LoadMatrix(double[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadMatrixd);

			unsafe
			{
				fixed (double* mPtr = m)
				{
					GLNative.LoadMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadMatrixd);
		}

		/// glLoadMatrixf
		/// Version: 1.0
		public void LoadMatrix(float[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadMatrixf);

			unsafe
			{
				fixed (float* mPtr = m)
				{
					GLNative.LoadMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadMatrixf);
		}

		/// glLoadMatrixf
		/// Version: 1.0
		public void LoadMatrix(ref float m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadMatrixf);

			unsafe
			{
				fixed (float* mPtr = &m)
				{
					GLNative.LoadMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadMatrixf);
		}

		/// glLoadName
		/// Version: 1.0
		public void LoadName(uint name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadName);

			GLNative.LoadName(name);

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadName);
		}

		private GLNative.LoadTransposeMatrixd _LoadTransposeMatrixd;

		/// glLoadTransposeMatrixd
		/// Version: 1.3
		public void LoadTransposeMatrix(double[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixd);

			unsafe
			{
				fixed (double* mPtr = m)
				{
					if (this._LoadTransposeMatrixd == null)
						this._LoadTransposeMatrixd = (GLNative.LoadTransposeMatrixd)this.LoadExtensionFunction<GLNative.LoadTransposeMatrixd>();

					this._LoadTransposeMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixd);
		}

		/// glLoadTransposeMatrixd
		/// Version: 1.3
		public void LoadTransposeMatrix(ref double m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixd);

			unsafe
			{
				fixed (double* mPtr = &m)
				{
					if (this._LoadTransposeMatrixd == null)
						this._LoadTransposeMatrixd = (GLNative.LoadTransposeMatrixd)this.LoadExtensionFunction<GLNative.LoadTransposeMatrixd>();

					this._LoadTransposeMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixd);
		}

		private GLNative.LoadTransposeMatrixf _LoadTransposeMatrixf;

		/// glLoadTransposeMatrixf
		/// Version: 1.3
		public void LoadTransposeMatrix(float[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixf);

			unsafe
			{
				fixed (float* mPtr = m)
				{
					if (this._LoadTransposeMatrixf == null)
						this._LoadTransposeMatrixf = (GLNative.LoadTransposeMatrixf)this.LoadExtensionFunction<GLNative.LoadTransposeMatrixf>();

					this._LoadTransposeMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixf);
		}

		/// glLoadTransposeMatrixf
		/// Version: 1.3
		public void LoadTransposeMatrix(ref float m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixf);

			unsafe
			{
				fixed (float* mPtr = &m)
				{
					if (this._LoadTransposeMatrixf == null)
						this._LoadTransposeMatrixf = (GLNative.LoadTransposeMatrixf)this.LoadExtensionFunction<GLNative.LoadTransposeMatrixf>();

					this._LoadTransposeMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.LoadTransposeMatrixf);
		}

		/// glLogicOp
		/// Version: 1.0
		public void LogicOp(LogicOp opcode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LogicOp);

			GLNative.LogicOp((uint)opcode);

			this.AfterNativeFunctionCall(GLNativeFunctions.LogicOp);
		}

		/// glLogicOp
		/// Version: 1.0
		public void LogicOp(uint opcode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.LogicOp);

			GLNative.LogicOp(opcode);

			this.AfterNativeFunctionCall(GLNativeFunctions.LogicOp);
		}

		/// glMap1d
		/// Version: 1.0
		public void Map1(uint target, double u1, double u2, int stride, int order, ref double points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1d);

			unsafe
			{
				fixed (double* pointsPtr = &points)
				{
					GLNative.Map1d(target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1d);
		}

		/// glMap1d
		/// Version: 1.0
		public void Map1(MapTarget target, double u1, double u2, int stride, int order, ref double points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1d);

			unsafe
			{
				fixed (double* pointsPtr = &points)
				{
					GLNative.Map1d((uint)target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1d);
		}

		/// glMap1d
		/// Version: 1.0
		public void Map1(MapTarget target, double u1, double u2, int stride, int order, double[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1d);

			unsafe
			{
				fixed (double* pointsPtr = points)
				{
					GLNative.Map1d((uint)target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1d);
		}

		/// glMap1d
		/// Version: 1.0
		public void Map1(uint target, double u1, double u2, int stride, int order, double[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1d);

			unsafe
			{
				fixed (double* pointsPtr = points)
				{
					GLNative.Map1d(target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1d);
		}

		/// glMap1f
		/// Version: 1.0
		public void Map1(uint target, float u1, float u2, int stride, int order, float[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1f);

			unsafe
			{
				fixed (float* pointsPtr = points)
				{
					GLNative.Map1f(target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1f);
		}

		/// glMap1f
		/// Version: 1.0
		public void Map1(MapTarget target, float u1, float u2, int stride, int order, float[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1f);

			unsafe
			{
				fixed (float* pointsPtr = points)
				{
					GLNative.Map1f((uint)target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1f);
		}

		/// glMap1f
		/// Version: 1.0
		public void Map1(MapTarget target, float u1, float u2, int stride, int order, ref float points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1f);

			unsafe
			{
				fixed (float* pointsPtr = &points)
				{
					GLNative.Map1f((uint)target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1f);
		}

		/// glMap1f
		/// Version: 1.0
		public void Map1(uint target, float u1, float u2, int stride, int order, ref float points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map1f);

			unsafe
			{
				fixed (float* pointsPtr = &points)
				{
					GLNative.Map1f(target, u1, u2, stride, order, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map1f);
		}

		/// glMap2d
		/// Version: 1.0
		public void Map2(MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2d);

			unsafe
			{
				fixed (double* pointsPtr = points)
				{
					GLNative.Map2d((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2d);
		}

		/// glMap2d
		/// Version: 1.0
		public void Map2(uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2d);

			unsafe
			{
				fixed (double* pointsPtr = points)
				{
					GLNative.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2d);
		}

		/// glMap2d
		/// Version: 1.0
		public void Map2(MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, ref double points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2d);

			unsafe
			{
				fixed (double* pointsPtr = &points)
				{
					GLNative.Map2d((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2d);
		}

		/// glMap2d
		/// Version: 1.0
		public void Map2(uint target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, ref double points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2d);

			unsafe
			{
				fixed (double* pointsPtr = &points)
				{
					GLNative.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2d);
		}

		/// glMap2f
		/// Version: 1.0
		public void Map2(uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2f);

			unsafe
			{
				fixed (float* pointsPtr = points)
				{
					GLNative.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2f);
		}

		/// glMap2f
		/// Version: 1.0
		public void Map2(MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2f);

			unsafe
			{
				fixed (float* pointsPtr = points)
				{
					GLNative.Map2f((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2f);
		}

		/// glMap2f
		/// Version: 1.0
		public void Map2(MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, ref float points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2f);

			unsafe
			{
				fixed (float* pointsPtr = &points)
				{
					GLNative.Map2f((uint)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2f);
		}

		/// glMap2f
		/// Version: 1.0
		public void Map2(uint target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, ref float points)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Map2f);

			unsafe
			{
				fixed (float* pointsPtr = &points)
				{
					GLNative.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, pointsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Map2f);
		}

		private GLNative.MapBuffer _MapBuffer;

		/// glMapBuffer
		/// Version: 1.5
		public void MapBuffer(uint target, uint access)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapBuffer);

			if (this._MapBuffer == null)
				this._MapBuffer = (GLNative.MapBuffer)this.LoadExtensionFunction<GLNative.MapBuffer>();

			this._MapBuffer(target, access);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapBuffer);
		}

		private GLNative.MapBufferRange _MapBufferRange;

		/// glMapBufferRange
		/// Version: 3.0
		public void MapBufferRange(uint target, IntPtr offset, IntPtr length, uint access)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapBufferRange);

			if (this._MapBufferRange == null)
				this._MapBufferRange = (GLNative.MapBufferRange)this.LoadExtensionFunction<GLNative.MapBufferRange>();

			this._MapBufferRange(target, offset, length, access);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapBufferRange);
		}

		/// glMapGrid1d
		/// Version: 1.0
		public void MapGrid1(int un, double u1, double u2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapGrid1d);

			GLNative.MapGrid1d(un, u1, u2);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapGrid1d);
		}

		/// glMapGrid1f
		/// Version: 1.0
		public void MapGrid1(int un, float u1, float u2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapGrid1f);

			GLNative.MapGrid1f(un, u1, u2);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapGrid1f);
		}

		/// glMapGrid2d
		/// Version: 1.0
		public void MapGrid2(int un, double u1, double u2, int vn, double v1, double v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapGrid2d);

			GLNative.MapGrid2d(un, u1, u2, vn, v1, v2);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapGrid2d);
		}

		/// glMapGrid2f
		/// Version: 1.0
		public void MapGrid2(int un, float u1, float u2, int vn, float v1, float v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MapGrid2f);

			GLNative.MapGrid2f(un, u1, u2, vn, v1, v2);

			this.AfterNativeFunctionCall(GLNativeFunctions.MapGrid2f);
		}

		/// glMaterialf
		/// Version: 1.0
		public void Material(uint face, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialf);

			GLNative.Materialf(face, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialf);
		}

		/// glMaterialf
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialf);

			GLNative.Materialf((uint)face, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialf);
		}

		/// glMaterialfv
		/// Version: 1.0
		public void Material(uint face, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Materialfv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialfv);
		}

		/// glMaterialfv
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.Materialfv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialfv);
		}

		/// glMaterialfv
		/// Version: 1.0
		public void Material(uint face, uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Materialfv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialfv);
		}

		/// glMaterialfv
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.Materialfv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialfv);
		}

		/// glMateriali
		/// Version: 1.0
		public void Material(uint face, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materiali);

			GLNative.Materiali(face, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Materiali);
		}

		/// glMateriali
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materiali);

			GLNative.Materiali((uint)face, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.Materiali);
		}

		/// glMaterialiv
		/// Version: 1.0
		public void Material(uint face, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Materialiv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialiv);
		}

		/// glMaterialiv
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.Materialiv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialiv);
		}

		/// glMaterialiv
		/// Version: 1.0
		public void Material(uint face, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Materialiv(face, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialiv);
		}

		/// glMaterialiv
		/// Version: 1.0
		public void Material(MaterialFace face, MaterialParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Materialiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.Materialiv((uint)face, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Materialiv);
		}

		/// glMatrixMode
		/// Version: 1.0
		public void MatrixMode(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MatrixMode);

			GLNative.MatrixMode(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.MatrixMode);
		}

		/// glMatrixMode
		/// Version: 1.0
		public void MatrixMode(MatrixMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MatrixMode);

			GLNative.MatrixMode((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.MatrixMode);
		}

		/// glMultiDrawArrays
		/// Version: 1.4
		public void MultiDrawArrays(uint mode, ref int first, ref int count, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);

			unsafe
			{
				fixed (int* firstPtr = &first)
				fixed (int* countPtr = &count)
				{
					if (this._MultiDrawArrays == null)
						this._MultiDrawArrays = (GLNative.MultiDrawArrays)this.LoadExtensionFunction<GLNative.MultiDrawArrays>();

					this._MultiDrawArrays(mode, firstPtr, countPtr, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);
		}

		private GLNative.MultiDrawArrays _MultiDrawArrays;

		/// glMultiDrawArrays
		/// Version: 1.4
		public void MultiDrawArrays(uint mode, int[] first, int[] count, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);

			unsafe
			{
				fixed (int* firstPtr = first)
				fixed (int* countPtr = count)
				{
					if (this._MultiDrawArrays == null)
						this._MultiDrawArrays = (GLNative.MultiDrawArrays)this.LoadExtensionFunction<GLNative.MultiDrawArrays>();

					this._MultiDrawArrays(mode, firstPtr, countPtr, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);
		}

		/// glMultiDrawArrays
		/// Version: 1.4
		public void MultiDrawArrays(PrimitiveType mode, int[] first, int[] count, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);

			unsafe
			{
				fixed (int* firstPtr = first)
				fixed (int* countPtr = count)
				{
					if (this._MultiDrawArrays == null)
						this._MultiDrawArrays = (GLNative.MultiDrawArrays)this.LoadExtensionFunction<GLNative.MultiDrawArrays>();

					this._MultiDrawArrays((uint)mode, firstPtr, countPtr, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);
		}

		/// glMultiDrawArrays
		/// Version: 1.4
		public void MultiDrawArrays(PrimitiveType mode, ref int first, ref int count, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);

			unsafe
			{
				fixed (int* firstPtr = &first)
				fixed (int* countPtr = &count)
				{
					if (this._MultiDrawArrays == null)
						this._MultiDrawArrays = (GLNative.MultiDrawArrays)this.LoadExtensionFunction<GLNative.MultiDrawArrays>();

					this._MultiDrawArrays((uint)mode, firstPtr, countPtr, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawArrays);
		}

		/// glMultiDrawElements
		/// Version: 1.4
		public void MultiDrawElements(PrimitiveType mode, int[] count, DrawElementsType type, IntPtr indices, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElements);

			unsafe
			{
				fixed (int* countPtr = count)
				{
					if (this._MultiDrawElements == null)
						this._MultiDrawElements = (GLNative.MultiDrawElements)this.LoadExtensionFunction<GLNative.MultiDrawElements>();

					this._MultiDrawElements((uint)mode, countPtr, (uint)type, indices, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElements);
		}

		private GLNative.MultiDrawElements _MultiDrawElements;

		/// glMultiDrawElements
		/// Version: 1.4
		public void MultiDrawElements(uint mode, int[] count, uint type, IntPtr indices, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElements);

			unsafe
			{
				fixed (int* countPtr = count)
				{
					if (this._MultiDrawElements == null)
						this._MultiDrawElements = (GLNative.MultiDrawElements)this.LoadExtensionFunction<GLNative.MultiDrawElements>();

					this._MultiDrawElements(mode, countPtr, type, indices, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElements);
		}

		/// glMultiDrawElements
		/// Version: 1.4
		public void MultiDrawElements(uint mode, ref int count, uint type, IntPtr indices, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElements);

			unsafe
			{
				fixed (int* countPtr = &count)
				{
					if (this._MultiDrawElements == null)
						this._MultiDrawElements = (GLNative.MultiDrawElements)this.LoadExtensionFunction<GLNative.MultiDrawElements>();

					this._MultiDrawElements(mode, countPtr, type, indices, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElements);
		}

		/// glMultiDrawElements
		/// Version: 1.4
		public void MultiDrawElements(PrimitiveType mode, ref int count, DrawElementsType type, IntPtr indices, int drawcount)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElements);

			unsafe
			{
				fixed (int* countPtr = &count)
				{
					if (this._MultiDrawElements == null)
						this._MultiDrawElements = (GLNative.MultiDrawElements)this.LoadExtensionFunction<GLNative.MultiDrawElements>();

					this._MultiDrawElements((uint)mode, countPtr, (uint)type, indices, drawcount);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElements);
		}

		/// glMultiDrawElementsBaseVertex
		/// Version: 3.2
		public void MultiDrawElementsBaseVertex(uint mode, int[] count, DrawElementsType type, IntPtr indices, int drawcount, int[] basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);

			unsafe
			{
				fixed (int* countPtr = count)
				fixed (int* basevertexPtr = basevertex)
				{
					if (this._MultiDrawElementsBaseVertex == null)
						this._MultiDrawElementsBaseVertex = (GLNative.MultiDrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.MultiDrawElementsBaseVertex>();

					this._MultiDrawElementsBaseVertex(mode, countPtr, (uint)type, indices, drawcount, basevertexPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);
		}

		/// glMultiDrawElementsBaseVertex
		/// Version: 3.2
		public void MultiDrawElementsBaseVertex(uint mode, ref int count, uint type, IntPtr indices, int drawcount, ref int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);

			unsafe
			{
				fixed (int* countPtr = &count)
				fixed (int* basevertexPtr = &basevertex)
				{
					if (this._MultiDrawElementsBaseVertex == null)
						this._MultiDrawElementsBaseVertex = (GLNative.MultiDrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.MultiDrawElementsBaseVertex>();

					this._MultiDrawElementsBaseVertex(mode, countPtr, type, indices, drawcount, basevertexPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);
		}

		/// glMultiDrawElementsBaseVertex
		/// Version: 3.2
		public void MultiDrawElementsBaseVertex(uint mode, ref int count, DrawElementsType type, IntPtr indices, int drawcount, ref int basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);

			unsafe
			{
				fixed (int* countPtr = &count)
				fixed (int* basevertexPtr = &basevertex)
				{
					if (this._MultiDrawElementsBaseVertex == null)
						this._MultiDrawElementsBaseVertex = (GLNative.MultiDrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.MultiDrawElementsBaseVertex>();

					this._MultiDrawElementsBaseVertex(mode, countPtr, (uint)type, indices, drawcount, basevertexPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);
		}

		private GLNative.MultiDrawElementsBaseVertex _MultiDrawElementsBaseVertex;

		/// glMultiDrawElementsBaseVertex
		/// Version: 3.2
		public void MultiDrawElementsBaseVertex(uint mode, int[] count, uint type, IntPtr indices, int drawcount, int[] basevertex)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);

			unsafe
			{
				fixed (int* countPtr = count)
				fixed (int* basevertexPtr = basevertex)
				{
					if (this._MultiDrawElementsBaseVertex == null)
						this._MultiDrawElementsBaseVertex = (GLNative.MultiDrawElementsBaseVertex)this.LoadExtensionFunction<GLNative.MultiDrawElementsBaseVertex>();

					this._MultiDrawElementsBaseVertex(mode, countPtr, type, indices, drawcount, basevertexPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiDrawElementsBaseVertex);
		}

		private GLNative.MultiTexCoord1d _MultiTexCoord1d;

		/// glMultiTexCoord1d
		/// Version: 1.3
		public void MultiTexCoord1(uint target, double s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1d);

			if (this._MultiTexCoord1d == null)
				this._MultiTexCoord1d = (GLNative.MultiTexCoord1d)this.LoadExtensionFunction<GLNative.MultiTexCoord1d>();

			this._MultiTexCoord1d(target, s);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1d);
		}

		/// glMultiTexCoord1dv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._MultiTexCoord1dv == null)
						this._MultiTexCoord1dv = (GLNative.MultiTexCoord1dv)this.LoadExtensionFunction<GLNative.MultiTexCoord1dv>();

					this._MultiTexCoord1dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1dv);
		}

		private GLNative.MultiTexCoord1dv _MultiTexCoord1dv;

		/// glMultiTexCoord1dv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._MultiTexCoord1dv == null)
						this._MultiTexCoord1dv = (GLNative.MultiTexCoord1dv)this.LoadExtensionFunction<GLNative.MultiTexCoord1dv>();

					this._MultiTexCoord1dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1dv);
		}

		private GLNative.MultiTexCoord1f _MultiTexCoord1f;

		/// glMultiTexCoord1f
		/// Version: 1.3
		public void MultiTexCoord1(uint target, float s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1f);

			if (this._MultiTexCoord1f == null)
				this._MultiTexCoord1f = (GLNative.MultiTexCoord1f)this.LoadExtensionFunction<GLNative.MultiTexCoord1f>();

			this._MultiTexCoord1f(target, s);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1f);
		}

		/// glMultiTexCoord1fv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._MultiTexCoord1fv == null)
						this._MultiTexCoord1fv = (GLNative.MultiTexCoord1fv)this.LoadExtensionFunction<GLNative.MultiTexCoord1fv>();

					this._MultiTexCoord1fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1fv);
		}

		private GLNative.MultiTexCoord1fv _MultiTexCoord1fv;

		/// glMultiTexCoord1fv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._MultiTexCoord1fv == null)
						this._MultiTexCoord1fv = (GLNative.MultiTexCoord1fv)this.LoadExtensionFunction<GLNative.MultiTexCoord1fv>();

					this._MultiTexCoord1fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1fv);
		}

		private GLNative.MultiTexCoord1i _MultiTexCoord1i;

		/// glMultiTexCoord1i
		/// Version: 1.3
		public void MultiTexCoord1(uint target, int s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1i);

			if (this._MultiTexCoord1i == null)
				this._MultiTexCoord1i = (GLNative.MultiTexCoord1i)this.LoadExtensionFunction<GLNative.MultiTexCoord1i>();

			this._MultiTexCoord1i(target, s);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1i);
		}

		/// glMultiTexCoord1iv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._MultiTexCoord1iv == null)
						this._MultiTexCoord1iv = (GLNative.MultiTexCoord1iv)this.LoadExtensionFunction<GLNative.MultiTexCoord1iv>();

					this._MultiTexCoord1iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1iv);
		}

		private GLNative.MultiTexCoord1iv _MultiTexCoord1iv;

		/// glMultiTexCoord1iv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._MultiTexCoord1iv == null)
						this._MultiTexCoord1iv = (GLNative.MultiTexCoord1iv)this.LoadExtensionFunction<GLNative.MultiTexCoord1iv>();

					this._MultiTexCoord1iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1iv);
		}

		private GLNative.MultiTexCoord1s _MultiTexCoord1s;

		/// glMultiTexCoord1s
		/// Version: 1.3
		public void MultiTexCoord1(uint target, short s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1s);

			if (this._MultiTexCoord1s == null)
				this._MultiTexCoord1s = (GLNative.MultiTexCoord1s)this.LoadExtensionFunction<GLNative.MultiTexCoord1s>();

			this._MultiTexCoord1s(target, s);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1s);
		}

		/// glMultiTexCoord1sv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._MultiTexCoord1sv == null)
						this._MultiTexCoord1sv = (GLNative.MultiTexCoord1sv)this.LoadExtensionFunction<GLNative.MultiTexCoord1sv>();

					this._MultiTexCoord1sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1sv);
		}

		private GLNative.MultiTexCoord1sv _MultiTexCoord1sv;

		/// glMultiTexCoord1sv
		/// Version: 1.3
		public void MultiTexCoord1(uint target, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord1sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._MultiTexCoord1sv == null)
						this._MultiTexCoord1sv = (GLNative.MultiTexCoord1sv)this.LoadExtensionFunction<GLNative.MultiTexCoord1sv>();

					this._MultiTexCoord1sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord1sv);
		}

		private GLNative.MultiTexCoord2d _MultiTexCoord2d;

		/// glMultiTexCoord2d
		/// Version: 1.3
		public void MultiTexCoord2(uint target, double s, double t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2d);

			if (this._MultiTexCoord2d == null)
				this._MultiTexCoord2d = (GLNative.MultiTexCoord2d)this.LoadExtensionFunction<GLNative.MultiTexCoord2d>();

			this._MultiTexCoord2d(target, s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2d);
		}

		/// glMultiTexCoord2dv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._MultiTexCoord2dv == null)
						this._MultiTexCoord2dv = (GLNative.MultiTexCoord2dv)this.LoadExtensionFunction<GLNative.MultiTexCoord2dv>();

					this._MultiTexCoord2dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2dv);
		}

		private GLNative.MultiTexCoord2dv _MultiTexCoord2dv;

		/// glMultiTexCoord2dv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._MultiTexCoord2dv == null)
						this._MultiTexCoord2dv = (GLNative.MultiTexCoord2dv)this.LoadExtensionFunction<GLNative.MultiTexCoord2dv>();

					this._MultiTexCoord2dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2dv);
		}

		private GLNative.MultiTexCoord2f _MultiTexCoord2f;

		/// glMultiTexCoord2f
		/// Version: 1.3
		public void MultiTexCoord2(uint target, float s, float t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2f);

			if (this._MultiTexCoord2f == null)
				this._MultiTexCoord2f = (GLNative.MultiTexCoord2f)this.LoadExtensionFunction<GLNative.MultiTexCoord2f>();

			this._MultiTexCoord2f(target, s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2f);
		}

		/// glMultiTexCoord2fv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._MultiTexCoord2fv == null)
						this._MultiTexCoord2fv = (GLNative.MultiTexCoord2fv)this.LoadExtensionFunction<GLNative.MultiTexCoord2fv>();

					this._MultiTexCoord2fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2fv);
		}

		private GLNative.MultiTexCoord2fv _MultiTexCoord2fv;

		/// glMultiTexCoord2fv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._MultiTexCoord2fv == null)
						this._MultiTexCoord2fv = (GLNative.MultiTexCoord2fv)this.LoadExtensionFunction<GLNative.MultiTexCoord2fv>();

					this._MultiTexCoord2fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2fv);
		}

		private GLNative.MultiTexCoord2i _MultiTexCoord2i;

		/// glMultiTexCoord2i
		/// Version: 1.3
		public void MultiTexCoord2(uint target, int s, int t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2i);

			if (this._MultiTexCoord2i == null)
				this._MultiTexCoord2i = (GLNative.MultiTexCoord2i)this.LoadExtensionFunction<GLNative.MultiTexCoord2i>();

			this._MultiTexCoord2i(target, s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2i);
		}

		/// glMultiTexCoord2iv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._MultiTexCoord2iv == null)
						this._MultiTexCoord2iv = (GLNative.MultiTexCoord2iv)this.LoadExtensionFunction<GLNative.MultiTexCoord2iv>();

					this._MultiTexCoord2iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2iv);
		}

		private GLNative.MultiTexCoord2iv _MultiTexCoord2iv;

		/// glMultiTexCoord2iv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._MultiTexCoord2iv == null)
						this._MultiTexCoord2iv = (GLNative.MultiTexCoord2iv)this.LoadExtensionFunction<GLNative.MultiTexCoord2iv>();

					this._MultiTexCoord2iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2iv);
		}

		private GLNative.MultiTexCoord2s _MultiTexCoord2s;

		/// glMultiTexCoord2s
		/// Version: 1.3
		public void MultiTexCoord2(uint target, short s, short t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2s);

			if (this._MultiTexCoord2s == null)
				this._MultiTexCoord2s = (GLNative.MultiTexCoord2s)this.LoadExtensionFunction<GLNative.MultiTexCoord2s>();

			this._MultiTexCoord2s(target, s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2s);
		}

		private GLNative.MultiTexCoord2sv _MultiTexCoord2sv;

		/// glMultiTexCoord2sv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._MultiTexCoord2sv == null)
						this._MultiTexCoord2sv = (GLNative.MultiTexCoord2sv)this.LoadExtensionFunction<GLNative.MultiTexCoord2sv>();

					this._MultiTexCoord2sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2sv);
		}

		/// glMultiTexCoord2sv
		/// Version: 1.3
		public void MultiTexCoord2(uint target, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._MultiTexCoord2sv == null)
						this._MultiTexCoord2sv = (GLNative.MultiTexCoord2sv)this.LoadExtensionFunction<GLNative.MultiTexCoord2sv>();

					this._MultiTexCoord2sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord2sv);
		}

		private GLNative.MultiTexCoord3d _MultiTexCoord3d;

		/// glMultiTexCoord3d
		/// Version: 1.3
		public void MultiTexCoord3(uint target, double s, double t, double r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3d);

			if (this._MultiTexCoord3d == null)
				this._MultiTexCoord3d = (GLNative.MultiTexCoord3d)this.LoadExtensionFunction<GLNative.MultiTexCoord3d>();

			this._MultiTexCoord3d(target, s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3d);
		}

		/// glMultiTexCoord3dv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._MultiTexCoord3dv == null)
						this._MultiTexCoord3dv = (GLNative.MultiTexCoord3dv)this.LoadExtensionFunction<GLNative.MultiTexCoord3dv>();

					this._MultiTexCoord3dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3dv);
		}

		private GLNative.MultiTexCoord3dv _MultiTexCoord3dv;

		/// glMultiTexCoord3dv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._MultiTexCoord3dv == null)
						this._MultiTexCoord3dv = (GLNative.MultiTexCoord3dv)this.LoadExtensionFunction<GLNative.MultiTexCoord3dv>();

					this._MultiTexCoord3dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3dv);
		}

		private GLNative.MultiTexCoord3f _MultiTexCoord3f;

		/// glMultiTexCoord3f
		/// Version: 1.3
		public void MultiTexCoord3(uint target, float s, float t, float r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3f);

			if (this._MultiTexCoord3f == null)
				this._MultiTexCoord3f = (GLNative.MultiTexCoord3f)this.LoadExtensionFunction<GLNative.MultiTexCoord3f>();

			this._MultiTexCoord3f(target, s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3f);
		}

		/// glMultiTexCoord3fv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._MultiTexCoord3fv == null)
						this._MultiTexCoord3fv = (GLNative.MultiTexCoord3fv)this.LoadExtensionFunction<GLNative.MultiTexCoord3fv>();

					this._MultiTexCoord3fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3fv);
		}

		private GLNative.MultiTexCoord3fv _MultiTexCoord3fv;

		/// glMultiTexCoord3fv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._MultiTexCoord3fv == null)
						this._MultiTexCoord3fv = (GLNative.MultiTexCoord3fv)this.LoadExtensionFunction<GLNative.MultiTexCoord3fv>();

					this._MultiTexCoord3fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3fv);
		}

		private GLNative.MultiTexCoord3i _MultiTexCoord3i;

		/// glMultiTexCoord3i
		/// Version: 1.3
		public void MultiTexCoord3(uint target, int s, int t, int r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3i);

			if (this._MultiTexCoord3i == null)
				this._MultiTexCoord3i = (GLNative.MultiTexCoord3i)this.LoadExtensionFunction<GLNative.MultiTexCoord3i>();

			this._MultiTexCoord3i(target, s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3i);
		}

		private GLNative.MultiTexCoord3iv _MultiTexCoord3iv;

		/// glMultiTexCoord3iv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._MultiTexCoord3iv == null)
						this._MultiTexCoord3iv = (GLNative.MultiTexCoord3iv)this.LoadExtensionFunction<GLNative.MultiTexCoord3iv>();

					this._MultiTexCoord3iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3iv);
		}

		/// glMultiTexCoord3iv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._MultiTexCoord3iv == null)
						this._MultiTexCoord3iv = (GLNative.MultiTexCoord3iv)this.LoadExtensionFunction<GLNative.MultiTexCoord3iv>();

					this._MultiTexCoord3iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3iv);
		}

		private GLNative.MultiTexCoord3s _MultiTexCoord3s;

		/// glMultiTexCoord3s
		/// Version: 1.3
		public void MultiTexCoord3(uint target, short s, short t, short r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3s);

			if (this._MultiTexCoord3s == null)
				this._MultiTexCoord3s = (GLNative.MultiTexCoord3s)this.LoadExtensionFunction<GLNative.MultiTexCoord3s>();

			this._MultiTexCoord3s(target, s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3s);
		}

		/// glMultiTexCoord3sv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._MultiTexCoord3sv == null)
						this._MultiTexCoord3sv = (GLNative.MultiTexCoord3sv)this.LoadExtensionFunction<GLNative.MultiTexCoord3sv>();

					this._MultiTexCoord3sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3sv);
		}

		private GLNative.MultiTexCoord3sv _MultiTexCoord3sv;

		/// glMultiTexCoord3sv
		/// Version: 1.3
		public void MultiTexCoord3(uint target, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._MultiTexCoord3sv == null)
						this._MultiTexCoord3sv = (GLNative.MultiTexCoord3sv)this.LoadExtensionFunction<GLNative.MultiTexCoord3sv>();

					this._MultiTexCoord3sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord3sv);
		}

		private GLNative.MultiTexCoord4d _MultiTexCoord4d;

		/// glMultiTexCoord4d
		/// Version: 1.3
		public void MultiTexCoord4(uint target, double s, double t, double r, double q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4d);

			if (this._MultiTexCoord4d == null)
				this._MultiTexCoord4d = (GLNative.MultiTexCoord4d)this.LoadExtensionFunction<GLNative.MultiTexCoord4d>();

			this._MultiTexCoord4d(target, s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4d);
		}

		private GLNative.MultiTexCoord4dv _MultiTexCoord4dv;

		/// glMultiTexCoord4dv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._MultiTexCoord4dv == null)
						this._MultiTexCoord4dv = (GLNative.MultiTexCoord4dv)this.LoadExtensionFunction<GLNative.MultiTexCoord4dv>();

					this._MultiTexCoord4dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4dv);
		}

		/// glMultiTexCoord4dv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._MultiTexCoord4dv == null)
						this._MultiTexCoord4dv = (GLNative.MultiTexCoord4dv)this.LoadExtensionFunction<GLNative.MultiTexCoord4dv>();

					this._MultiTexCoord4dv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4dv);
		}

		private GLNative.MultiTexCoord4f _MultiTexCoord4f;

		/// glMultiTexCoord4f
		/// Version: 1.3
		public void MultiTexCoord4(uint target, float s, float t, float r, float q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4f);

			if (this._MultiTexCoord4f == null)
				this._MultiTexCoord4f = (GLNative.MultiTexCoord4f)this.LoadExtensionFunction<GLNative.MultiTexCoord4f>();

			this._MultiTexCoord4f(target, s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4f);
		}

		/// glMultiTexCoord4fv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._MultiTexCoord4fv == null)
						this._MultiTexCoord4fv = (GLNative.MultiTexCoord4fv)this.LoadExtensionFunction<GLNative.MultiTexCoord4fv>();

					this._MultiTexCoord4fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4fv);
		}

		private GLNative.MultiTexCoord4fv _MultiTexCoord4fv;

		/// glMultiTexCoord4fv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._MultiTexCoord4fv == null)
						this._MultiTexCoord4fv = (GLNative.MultiTexCoord4fv)this.LoadExtensionFunction<GLNative.MultiTexCoord4fv>();

					this._MultiTexCoord4fv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4fv);
		}

		private GLNative.MultiTexCoord4i _MultiTexCoord4i;

		/// glMultiTexCoord4i
		/// Version: 1.3
		public void MultiTexCoord4(uint target, int s, int t, int r, int q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4i);

			if (this._MultiTexCoord4i == null)
				this._MultiTexCoord4i = (GLNative.MultiTexCoord4i)this.LoadExtensionFunction<GLNative.MultiTexCoord4i>();

			this._MultiTexCoord4i(target, s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4i);
		}

		private GLNative.MultiTexCoord4iv _MultiTexCoord4iv;

		/// glMultiTexCoord4iv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._MultiTexCoord4iv == null)
						this._MultiTexCoord4iv = (GLNative.MultiTexCoord4iv)this.LoadExtensionFunction<GLNative.MultiTexCoord4iv>();

					this._MultiTexCoord4iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4iv);
		}

		/// glMultiTexCoord4iv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._MultiTexCoord4iv == null)
						this._MultiTexCoord4iv = (GLNative.MultiTexCoord4iv)this.LoadExtensionFunction<GLNative.MultiTexCoord4iv>();

					this._MultiTexCoord4iv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4iv);
		}

		private GLNative.MultiTexCoord4s _MultiTexCoord4s;

		/// glMultiTexCoord4s
		/// Version: 1.3
		public void MultiTexCoord4(uint target, short s, short t, short r, short q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4s);

			if (this._MultiTexCoord4s == null)
				this._MultiTexCoord4s = (GLNative.MultiTexCoord4s)this.LoadExtensionFunction<GLNative.MultiTexCoord4s>();

			this._MultiTexCoord4s(target, s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4s);
		}

		private GLNative.MultiTexCoord4sv _MultiTexCoord4sv;

		/// glMultiTexCoord4sv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._MultiTexCoord4sv == null)
						this._MultiTexCoord4sv = (GLNative.MultiTexCoord4sv)this.LoadExtensionFunction<GLNative.MultiTexCoord4sv>();

					this._MultiTexCoord4sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4sv);
		}

		/// glMultiTexCoord4sv
		/// Version: 1.3
		public void MultiTexCoord4(uint target, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoord4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._MultiTexCoord4sv == null)
						this._MultiTexCoord4sv = (GLNative.MultiTexCoord4sv)this.LoadExtensionFunction<GLNative.MultiTexCoord4sv>();

					this._MultiTexCoord4sv(target, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoord4sv);
		}

		private GLNative.MultiTexCoordP1ui _MultiTexCoordP1ui;

		/// glMultiTexCoordP1ui
		/// Version: 3.3
		public void MultiTexCoordP1(uint texture, uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1ui);

			if (this._MultiTexCoordP1ui == null)
				this._MultiTexCoordP1ui = (GLNative.MultiTexCoordP1ui)this.LoadExtensionFunction<GLNative.MultiTexCoordP1ui>();

			this._MultiTexCoordP1ui(texture, type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1ui);
		}

		/// glMultiTexCoordP1uiv
		/// Version: 3.3
		public void MultiTexCoordP1(uint texture, uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._MultiTexCoordP1uiv == null)
						this._MultiTexCoordP1uiv = (GLNative.MultiTexCoordP1uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP1uiv>();

					this._MultiTexCoordP1uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1uiv);
		}

		private GLNative.MultiTexCoordP1uiv _MultiTexCoordP1uiv;

		/// glMultiTexCoordP1uiv
		/// Version: 3.3
		public void MultiTexCoordP1(uint texture, uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._MultiTexCoordP1uiv == null)
						this._MultiTexCoordP1uiv = (GLNative.MultiTexCoordP1uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP1uiv>();

					this._MultiTexCoordP1uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP1uiv);
		}

		private GLNative.MultiTexCoordP2ui _MultiTexCoordP2ui;

		/// glMultiTexCoordP2ui
		/// Version: 3.3
		public void MultiTexCoordP2(uint texture, uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2ui);

			if (this._MultiTexCoordP2ui == null)
				this._MultiTexCoordP2ui = (GLNative.MultiTexCoordP2ui)this.LoadExtensionFunction<GLNative.MultiTexCoordP2ui>();

			this._MultiTexCoordP2ui(texture, type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2ui);
		}

		/// glMultiTexCoordP2uiv
		/// Version: 3.3
		public void MultiTexCoordP2(uint texture, uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._MultiTexCoordP2uiv == null)
						this._MultiTexCoordP2uiv = (GLNative.MultiTexCoordP2uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP2uiv>();

					this._MultiTexCoordP2uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2uiv);
		}

		private GLNative.MultiTexCoordP2uiv _MultiTexCoordP2uiv;

		/// glMultiTexCoordP2uiv
		/// Version: 3.3
		public void MultiTexCoordP2(uint texture, uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._MultiTexCoordP2uiv == null)
						this._MultiTexCoordP2uiv = (GLNative.MultiTexCoordP2uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP2uiv>();

					this._MultiTexCoordP2uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP2uiv);
		}

		private GLNative.MultiTexCoordP3ui _MultiTexCoordP3ui;

		/// glMultiTexCoordP3ui
		/// Version: 3.3
		public void MultiTexCoordP3(uint texture, uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3ui);

			if (this._MultiTexCoordP3ui == null)
				this._MultiTexCoordP3ui = (GLNative.MultiTexCoordP3ui)this.LoadExtensionFunction<GLNative.MultiTexCoordP3ui>();

			this._MultiTexCoordP3ui(texture, type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3ui);
		}

		private GLNative.MultiTexCoordP3uiv _MultiTexCoordP3uiv;

		/// glMultiTexCoordP3uiv
		/// Version: 3.3
		public void MultiTexCoordP3(uint texture, uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._MultiTexCoordP3uiv == null)
						this._MultiTexCoordP3uiv = (GLNative.MultiTexCoordP3uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP3uiv>();

					this._MultiTexCoordP3uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3uiv);
		}

		/// glMultiTexCoordP3uiv
		/// Version: 3.3
		public void MultiTexCoordP3(uint texture, uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._MultiTexCoordP3uiv == null)
						this._MultiTexCoordP3uiv = (GLNative.MultiTexCoordP3uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP3uiv>();

					this._MultiTexCoordP3uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP3uiv);
		}

		private GLNative.MultiTexCoordP4ui _MultiTexCoordP4ui;

		/// glMultiTexCoordP4ui
		/// Version: 3.3
		public void MultiTexCoordP4(uint texture, uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4ui);

			if (this._MultiTexCoordP4ui == null)
				this._MultiTexCoordP4ui = (GLNative.MultiTexCoordP4ui)this.LoadExtensionFunction<GLNative.MultiTexCoordP4ui>();

			this._MultiTexCoordP4ui(texture, type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4ui);
		}

		/// glMultiTexCoordP4uiv
		/// Version: 3.3
		public void MultiTexCoordP4(uint texture, uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._MultiTexCoordP4uiv == null)
						this._MultiTexCoordP4uiv = (GLNative.MultiTexCoordP4uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP4uiv>();

					this._MultiTexCoordP4uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4uiv);
		}

		private GLNative.MultiTexCoordP4uiv _MultiTexCoordP4uiv;

		/// glMultiTexCoordP4uiv
		/// Version: 3.3
		public void MultiTexCoordP4(uint texture, uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._MultiTexCoordP4uiv == null)
						this._MultiTexCoordP4uiv = (GLNative.MultiTexCoordP4uiv)this.LoadExtensionFunction<GLNative.MultiTexCoordP4uiv>();

					this._MultiTexCoordP4uiv(texture, type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultiTexCoordP4uiv);
		}

		/// glMultMatrixd
		/// Version: 1.0
		public void MultMatrix(ref double m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultMatrixd);

			unsafe
			{
				fixed (double* mPtr = &m)
				{
					GLNative.MultMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultMatrixd);
		}

		/// glMultMatrixd
		/// Version: 1.0
		public void MultMatrix(double[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultMatrixd);

			unsafe
			{
				fixed (double* mPtr = m)
				{
					GLNative.MultMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultMatrixd);
		}

		/// glMultMatrixf
		/// Version: 1.0
		public void MultMatrix(float[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultMatrixf);

			unsafe
			{
				fixed (float* mPtr = m)
				{
					GLNative.MultMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultMatrixf);
		}

		/// glMultMatrixf
		/// Version: 1.0
		public void MultMatrix(ref float m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultMatrixf);

			unsafe
			{
				fixed (float* mPtr = &m)
				{
					GLNative.MultMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultMatrixf);
		}

		/// glMultTransposeMatrixd
		/// Version: 1.3
		public void MultTransposeMatrix(ref double m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixd);

			unsafe
			{
				fixed (double* mPtr = &m)
				{
					if (this._MultTransposeMatrixd == null)
						this._MultTransposeMatrixd = (GLNative.MultTransposeMatrixd)this.LoadExtensionFunction<GLNative.MultTransposeMatrixd>();

					this._MultTransposeMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixd);
		}

		private GLNative.MultTransposeMatrixd _MultTransposeMatrixd;

		/// glMultTransposeMatrixd
		/// Version: 1.3
		public void MultTransposeMatrix(double[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixd);

			unsafe
			{
				fixed (double* mPtr = m)
				{
					if (this._MultTransposeMatrixd == null)
						this._MultTransposeMatrixd = (GLNative.MultTransposeMatrixd)this.LoadExtensionFunction<GLNative.MultTransposeMatrixd>();

					this._MultTransposeMatrixd(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixd);
		}

		private GLNative.MultTransposeMatrixf _MultTransposeMatrixf;

		/// glMultTransposeMatrixf
		/// Version: 1.3
		public void MultTransposeMatrix(float[] m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixf);

			unsafe
			{
				fixed (float* mPtr = m)
				{
					if (this._MultTransposeMatrixf == null)
						this._MultTransposeMatrixf = (GLNative.MultTransposeMatrixf)this.LoadExtensionFunction<GLNative.MultTransposeMatrixf>();

					this._MultTransposeMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixf);
		}

		/// glMultTransposeMatrixf
		/// Version: 1.3
		public void MultTransposeMatrix(ref float m)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixf);

			unsafe
			{
				fixed (float* mPtr = &m)
				{
					if (this._MultTransposeMatrixf == null)
						this._MultTransposeMatrixf = (GLNative.MultTransposeMatrixf)this.LoadExtensionFunction<GLNative.MultTransposeMatrixf>();

					this._MultTransposeMatrixf(mPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.MultTransposeMatrixf);
		}

		/// glNewList
		/// Version: 1.0
		public void NewList(uint list, uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NewList);

			GLNative.NewList(list, mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.NewList);
		}

		/// glNewList
		/// Version: 1.0
		public void NewList(uint list, ListMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NewList);

			GLNative.NewList(list, (uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.NewList);
		}

		/// glNormal3b
		/// Version: 1.0
		public void Normal3(sbyte nx, sbyte ny, sbyte nz)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3b);

			GLNative.Normal3b(nx, ny, nz);

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3b);
		}

		/// glNormal3bv
		/// Version: 1.0
		public void Normal3(sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					GLNative.Normal3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3bv);
		}

		/// glNormal3bv
		/// Version: 1.0
		public void Normal3(ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					GLNative.Normal3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3bv);
		}

		/// glNormal3d
		/// Version: 1.0
		public void Normal3(double nx, double ny, double nz)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3d);

			GLNative.Normal3d(nx, ny, nz);

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3d);
		}

		/// glNormal3dv
		/// Version: 1.0
		public void Normal3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Normal3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3dv);
		}

		/// glNormal3dv
		/// Version: 1.0
		public void Normal3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Normal3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3dv);
		}

		/// glNormal3f
		/// Version: 1.0
		public void Normal3(float nx, float ny, float nz)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3f);

			GLNative.Normal3f(nx, ny, nz);

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3f);
		}

		/// glNormal3fv
		/// Version: 1.0
		public void Normal3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Normal3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3fv);
		}

		/// glNormal3fv
		/// Version: 1.0
		public void Normal3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Normal3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3fv);
		}

		/// glNormal3i
		/// Version: 1.0
		public void Normal3(int nx, int ny, int nz)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3i);

			GLNative.Normal3i(nx, ny, nz);

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3i);
		}

		/// glNormal3iv
		/// Version: 1.0
		public void Normal3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Normal3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3iv);
		}

		/// glNormal3iv
		/// Version: 1.0
		public void Normal3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Normal3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3iv);
		}

		/// glNormal3s
		/// Version: 1.0
		public void Normal3(short nx, short ny, short nz)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3s);

			GLNative.Normal3s(nx, ny, nz);

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3s);
		}

		/// glNormal3sv
		/// Version: 1.0
		public void Normal3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Normal3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3sv);
		}

		/// glNormal3sv
		/// Version: 1.0
		public void Normal3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Normal3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Normal3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Normal3sv);
		}

		private GLNative.NormalP3ui _NormalP3ui;

		/// glNormalP3ui
		/// Version: 3.3
		public void NormalP3(uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalP3ui);

			if (this._NormalP3ui == null)
				this._NormalP3ui = (GLNative.NormalP3ui)this.LoadExtensionFunction<GLNative.NormalP3ui>();

			this._NormalP3ui(type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalP3ui);
		}

		private GLNative.NormalP3uiv _NormalP3uiv;

		/// glNormalP3uiv
		/// Version: 3.3
		public void NormalP3(uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._NormalP3uiv == null)
						this._NormalP3uiv = (GLNative.NormalP3uiv)this.LoadExtensionFunction<GLNative.NormalP3uiv>();

					this._NormalP3uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalP3uiv);
		}

		/// glNormalP3uiv
		/// Version: 3.3
		public void NormalP3(uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._NormalP3uiv == null)
						this._NormalP3uiv = (GLNative.NormalP3uiv)this.LoadExtensionFunction<GLNative.NormalP3uiv>();

					this._NormalP3uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalP3uiv);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer<T>(NormalPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.NormalPointer((uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer<T>(uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.NormalPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer(NormalPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GLNative.NormalPointer((uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer<T>(NormalPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.NormalPointer((uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer(uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GLNative.NormalPointer(type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glNormalPointer
		/// Version: 1.1
		public void NormalPointer<T>(uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.NormalPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.NormalPointer(type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.NormalPointer);
		}

		/// glOrtho
		/// Version: 1.0
		public void Ortho(double left, double right, double bottom, double top, double zNear, double zFar)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Ortho);

			GLNative.Ortho(left, right, bottom, top, zNear, zFar);

			this.AfterNativeFunctionCall(GLNativeFunctions.Ortho);
		}

		/// glPassThrough
		/// Version: 1.0
		public void PassThrough(float token)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PassThrough);

			GLNative.PassThrough(token);

			this.AfterNativeFunctionCall(GLNativeFunctions.PassThrough);
		}

		/// glPixelMapfv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, ref float values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = &values)
				{
					GLNative.PixelMapfv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapfv);
		}

		/// glPixelMapfv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, float[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = values)
				{
					GLNative.PixelMapfv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapfv);
		}

		/// glPixelMapfv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, float[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = values)
				{
					GLNative.PixelMapfv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapfv);
		}

		/// glPixelMapfv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, ref float values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapfv);

			unsafe
			{
				fixed (float* valuesPtr = &values)
				{
					GLNative.PixelMapfv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapfv);
		}

		/// glPixelMapuiv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, uint[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = values)
				{
					GLNative.PixelMapuiv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapuiv);
		}

		/// glPixelMapuiv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, ref uint values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = &values)
				{
					GLNative.PixelMapuiv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapuiv);
		}

		/// glPixelMapuiv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, ref uint values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = &values)
				{
					GLNative.PixelMapuiv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapuiv);
		}

		/// glPixelMapuiv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, uint[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapuiv);

			unsafe
			{
				fixed (uint* valuesPtr = values)
				{
					GLNative.PixelMapuiv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapuiv);
		}

		/// glPixelMapusv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, ref ushort values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = &values)
				{
					GLNative.PixelMapusv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapusv);
		}

		/// glPixelMapusv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, ref ushort values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = &values)
				{
					GLNative.PixelMapusv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapusv);
		}

		/// glPixelMapusv
		/// Version: 1.0
		public void PixelMap(uint map, int mapsize, ushort[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = values)
				{
					GLNative.PixelMapusv(map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapusv);
		}

		/// glPixelMapusv
		/// Version: 1.0
		public void PixelMap(PixelMap map, int mapsize, ushort[] values)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelMapusv);

			unsafe
			{
				fixed (ushort* valuesPtr = values)
				{
					GLNative.PixelMapusv((uint)map, mapsize, valuesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelMapusv);
		}

		/// glPixelStoref
		/// Version: 1.0
		public void PixelStore(uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelStoref);

			GLNative.PixelStoref(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelStoref);
		}

		/// glPixelStoref
		/// Version: 1.0
		public void PixelStore(PixelStoreParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelStoref);

			GLNative.PixelStoref((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelStoref);
		}

		/// glPixelStorei
		/// Version: 1.0
		public void PixelStore(PixelStoreParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelStorei);

			GLNative.PixelStorei((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelStorei);
		}

		/// glPixelStorei
		/// Version: 1.0
		public void PixelStore(uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelStorei);

			GLNative.PixelStorei(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelStorei);
		}

		/// glPixelTransferf
		/// Version: 1.0
		public void PixelTransfer(PixelTransferParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelTransferf);

			GLNative.PixelTransferf((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelTransferf);
		}

		/// glPixelTransferf
		/// Version: 1.0
		public void PixelTransfer(uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelTransferf);

			GLNative.PixelTransferf(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelTransferf);
		}

		/// glPixelTransferi
		/// Version: 1.0
		public void PixelTransfer(uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelTransferi);

			GLNative.PixelTransferi(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelTransferi);
		}

		/// glPixelTransferi
		/// Version: 1.0
		public void PixelTransfer(PixelTransferParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelTransferi);

			GLNative.PixelTransferi((uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelTransferi);
		}

		/// glPixelZoom
		/// Version: 1.0
		public void PixelZoom(float xfactor, float yfactor)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PixelZoom);

			GLNative.PixelZoom(xfactor, yfactor);

			this.AfterNativeFunctionCall(GLNativeFunctions.PixelZoom);
		}

		private GLNative.PointParameterf _PointParameterf;

		/// glPointParameterf
		/// Version: 1.4
		public void PointParameter(uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameterf);

			if (this._PointParameterf == null)
				this._PointParameterf = (GLNative.PointParameterf)this.LoadExtensionFunction<GLNative.PointParameterf>();

			this._PointParameterf(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameterf);
		}

		/// glPointParameterfv
		/// Version: 1.4
		public void PointParameter(uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					if (this._PointParameterfv == null)
						this._PointParameterfv = (GLNative.PointParameterfv)this.LoadExtensionFunction<GLNative.PointParameterfv>();

					this._PointParameterfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameterfv);
		}

		private GLNative.PointParameterfv _PointParameterfv;

		/// glPointParameterfv
		/// Version: 1.4
		public void PointParameter(uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					if (this._PointParameterfv == null)
						this._PointParameterfv = (GLNative.PointParameterfv)this.LoadExtensionFunction<GLNative.PointParameterfv>();

					this._PointParameterfv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameterfv);
		}

		private GLNative.PointParameteri _PointParameteri;

		/// glPointParameteri
		/// Version: 1.4
		public void PointParameter(uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameteri);

			if (this._PointParameteri == null)
				this._PointParameteri = (GLNative.PointParameteri)this.LoadExtensionFunction<GLNative.PointParameteri>();

			this._PointParameteri(pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameteri);
		}

		private GLNative.PointParameteriv _PointParameteriv;

		/// glPointParameteriv
		/// Version: 1.4
		public void PointParameter(uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._PointParameteriv == null)
						this._PointParameteriv = (GLNative.PointParameteriv)this.LoadExtensionFunction<GLNative.PointParameteriv>();

					this._PointParameteriv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameteriv);
		}

		/// glPointParameteriv
		/// Version: 1.4
		public void PointParameter(uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._PointParameteriv == null)
						this._PointParameteriv = (GLNative.PointParameteriv)this.LoadExtensionFunction<GLNative.PointParameteriv>();

					this._PointParameteriv(pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PointParameteriv);
		}

		/// glPointSize
		/// Version: 1.0
		public void PointSize(float size)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PointSize);

			GLNative.PointSize(size);

			this.AfterNativeFunctionCall(GLNativeFunctions.PointSize);
		}

		/// glPolygonMode
		/// Version: 1.0
		public void PolygonMode(uint face, uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PolygonMode);

			GLNative.PolygonMode(face, mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.PolygonMode);
		}

		/// glPolygonMode
		/// Version: 1.0
		public void PolygonMode(MaterialFace face, PolygonMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PolygonMode);

			GLNative.PolygonMode((uint)face, (uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.PolygonMode);
		}

		/// glPolygonOffset
		/// Version: 1.1
		public void PolygonOffset(float factor, float units)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PolygonOffset);

			GLNative.PolygonOffset(factor, units);

			this.AfterNativeFunctionCall(GLNativeFunctions.PolygonOffset);
		}

		/// glPolygonStipple
		/// Version: 1.0
		public void PolygonStipple(ref byte mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PolygonStipple);

			unsafe
			{
				fixed (byte* maskPtr = &mask)
				{
					GLNative.PolygonStipple(maskPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PolygonStipple);
		}

		/// glPolygonStipple
		/// Version: 1.0
		public void PolygonStipple(byte[] mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PolygonStipple);

			unsafe
			{
				fixed (byte* maskPtr = mask)
				{
					GLNative.PolygonStipple(maskPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PolygonStipple);
		}

		/// glPopAttrib
		/// Version: 1.0
		public void PopAttrib()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PopAttrib);

			GLNative.PopAttrib();

			this.AfterNativeFunctionCall(GLNativeFunctions.PopAttrib);
		}

		/// glPopClientAttrib
		/// Version: 1.1
		public void PopClientAttrib()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PopClientAttrib);

			GLNative.PopClientAttrib();

			this.AfterNativeFunctionCall(GLNativeFunctions.PopClientAttrib);
		}

		/// glPopMatrix
		/// Version: 1.0
		public void PopMatrix()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PopMatrix);

			GLNative.PopMatrix();

			this.AfterNativeFunctionCall(GLNativeFunctions.PopMatrix);
		}

		/// glPopName
		/// Version: 1.0
		public void PopName()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PopName);

			GLNative.PopName();

			this.AfterNativeFunctionCall(GLNativeFunctions.PopName);
		}

		private GLNative.PrimitiveRestartIndex _PrimitiveRestartIndex;

		/// glPrimitiveRestartIndex
		/// Version: 3.1
		public void PrimitiveRestartIndex(uint index)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PrimitiveRestartIndex);

			if (this._PrimitiveRestartIndex == null)
				this._PrimitiveRestartIndex = (GLNative.PrimitiveRestartIndex)this.LoadExtensionFunction<GLNative.PrimitiveRestartIndex>();

			this._PrimitiveRestartIndex(index);

			this.AfterNativeFunctionCall(GLNativeFunctions.PrimitiveRestartIndex);
		}

		/// glPrioritizeTextures
		/// Version: 1.1
		public void PrioritizeTextures(int n, ref uint textures, ref float priorities)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PrioritizeTextures);

			unsafe
			{
				fixed (uint* texturesPtr = &textures)
				fixed (float* prioritiesPtr = &priorities)
				{
					GLNative.PrioritizeTextures(n, texturesPtr, prioritiesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PrioritizeTextures);
		}

		/// glPrioritizeTextures
		/// Version: 1.1
		public void PrioritizeTextures(int n, uint[] textures, float[] priorities)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PrioritizeTextures);

			unsafe
			{
				fixed (uint* texturesPtr = textures)
				fixed (float* prioritiesPtr = priorities)
				{
					GLNative.PrioritizeTextures(n, texturesPtr, prioritiesPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.PrioritizeTextures);
		}

		private GLNative.ProvokingVertex _ProvokingVertex;

		/// glProvokingVertex
		/// Version: 3.2
		public void ProvokingVertex(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ProvokingVertex);

			if (this._ProvokingVertex == null)
				this._ProvokingVertex = (GLNative.ProvokingVertex)this.LoadExtensionFunction<GLNative.ProvokingVertex>();

			this._ProvokingVertex(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ProvokingVertex);
		}

		/// glPushAttrib
		/// Version: 1.0
		public void PushAttrib(AttribMask mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushAttrib);

			GLNative.PushAttrib((uint)mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.PushAttrib);
		}

		/// glPushAttrib
		/// Version: 1.0
		public void PushAttrib(uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushAttrib);

			GLNative.PushAttrib(mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.PushAttrib);
		}

		/// glPushClientAttrib
		/// Version: 1.1
		public void PushClientAttrib(ClientAttribMask mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushClientAttrib);

			GLNative.PushClientAttrib((uint)mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.PushClientAttrib);
		}

		/// glPushClientAttrib
		/// Version: 1.1
		public void PushClientAttrib(uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushClientAttrib);

			GLNative.PushClientAttrib(mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.PushClientAttrib);
		}

		/// glPushMatrix
		/// Version: 1.0
		public void PushMatrix()
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushMatrix);

			GLNative.PushMatrix();

			this.AfterNativeFunctionCall(GLNativeFunctions.PushMatrix);
		}

		/// glPushName
		/// Version: 1.0
		public void PushName(uint name)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.PushName);

			GLNative.PushName(name);

			this.AfterNativeFunctionCall(GLNativeFunctions.PushName);
		}

		private GLNative.QueryCounter _QueryCounter;

		/// glQueryCounter
		/// Version: 3.3
		public void QueryCounter(uint id, uint target)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.QueryCounter);

			if (this._QueryCounter == null)
				this._QueryCounter = (GLNative.QueryCounter)this.LoadExtensionFunction<GLNative.QueryCounter>();

			this._QueryCounter(id, target);

			this.AfterNativeFunctionCall(GLNativeFunctions.QueryCounter);
		}

		/// glRasterPos2d
		/// Version: 1.0
		public void RasterPos2(double x, double y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2d);

			GLNative.RasterPos2d(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2d);
		}

		/// glRasterPos2dv
		/// Version: 1.0
		public void RasterPos2(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.RasterPos2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2dv);
		}

		/// glRasterPos2dv
		/// Version: 1.0
		public void RasterPos2(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.RasterPos2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2dv);
		}

		/// glRasterPos2f
		/// Version: 1.0
		public void RasterPos2(float x, float y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2f);

			GLNative.RasterPos2f(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2f);
		}

		/// glRasterPos2fv
		/// Version: 1.0
		public void RasterPos2(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.RasterPos2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2fv);
		}

		/// glRasterPos2fv
		/// Version: 1.0
		public void RasterPos2(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.RasterPos2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2fv);
		}

		/// glRasterPos2i
		/// Version: 1.0
		public void RasterPos2(int x, int y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2i);

			GLNative.RasterPos2i(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2i);
		}

		/// glRasterPos2iv
		/// Version: 1.0
		public void RasterPos2(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.RasterPos2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2iv);
		}

		/// glRasterPos2iv
		/// Version: 1.0
		public void RasterPos2(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.RasterPos2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2iv);
		}

		/// glRasterPos2s
		/// Version: 1.0
		public void RasterPos2(short x, short y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2s);

			GLNative.RasterPos2s(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2s);
		}

		/// glRasterPos2sv
		/// Version: 1.0
		public void RasterPos2(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.RasterPos2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2sv);
		}

		/// glRasterPos2sv
		/// Version: 1.0
		public void RasterPos2(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.RasterPos2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos2sv);
		}

		/// glRasterPos3d
		/// Version: 1.0
		public void RasterPos3(double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3d);

			GLNative.RasterPos3d(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3d);
		}

		/// glRasterPos3dv
		/// Version: 1.0
		public void RasterPos3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.RasterPos3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3dv);
		}

		/// glRasterPos3dv
		/// Version: 1.0
		public void RasterPos3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.RasterPos3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3dv);
		}

		/// glRasterPos3f
		/// Version: 1.0
		public void RasterPos3(float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3f);

			GLNative.RasterPos3f(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3f);
		}

		/// glRasterPos3fv
		/// Version: 1.0
		public void RasterPos3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.RasterPos3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3fv);
		}

		/// glRasterPos3fv
		/// Version: 1.0
		public void RasterPos3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.RasterPos3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3fv);
		}

		/// glRasterPos3i
		/// Version: 1.0
		public void RasterPos3(int x, int y, int z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3i);

			GLNative.RasterPos3i(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3i);
		}

		/// glRasterPos3iv
		/// Version: 1.0
		public void RasterPos3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.RasterPos3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3iv);
		}

		/// glRasterPos3iv
		/// Version: 1.0
		public void RasterPos3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.RasterPos3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3iv);
		}

		/// glRasterPos3s
		/// Version: 1.0
		public void RasterPos3(short x, short y, short z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3s);

			GLNative.RasterPos3s(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3s);
		}

		/// glRasterPos3sv
		/// Version: 1.0
		public void RasterPos3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.RasterPos3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3sv);
		}

		/// glRasterPos3sv
		/// Version: 1.0
		public void RasterPos3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.RasterPos3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos3sv);
		}

		/// glRasterPos4d
		/// Version: 1.0
		public void RasterPos4(double x, double y, double z, double w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4d);

			GLNative.RasterPos4d(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4d);
		}

		/// glRasterPos4dv
		/// Version: 1.0
		public void RasterPos4(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.RasterPos4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4dv);
		}

		/// glRasterPos4dv
		/// Version: 1.0
		public void RasterPos4(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.RasterPos4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4dv);
		}

		/// glRasterPos4f
		/// Version: 1.0
		public void RasterPos4(float x, float y, float z, float w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4f);

			GLNative.RasterPos4f(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4f);
		}

		/// glRasterPos4fv
		/// Version: 1.0
		public void RasterPos4(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.RasterPos4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4fv);
		}

		/// glRasterPos4fv
		/// Version: 1.0
		public void RasterPos4(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.RasterPos4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4fv);
		}

		/// glRasterPos4i
		/// Version: 1.0
		public void RasterPos4(int x, int y, int z, int w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4i);

			GLNative.RasterPos4i(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4i);
		}

		/// glRasterPos4iv
		/// Version: 1.0
		public void RasterPos4(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.RasterPos4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4iv);
		}

		/// glRasterPos4iv
		/// Version: 1.0
		public void RasterPos4(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.RasterPos4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4iv);
		}

		/// glRasterPos4s
		/// Version: 1.0
		public void RasterPos4(short x, short y, short z, short w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4s);

			GLNative.RasterPos4s(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4s);
		}

		/// glRasterPos4sv
		/// Version: 1.0
		public void RasterPos4(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.RasterPos4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4sv);
		}

		/// glRasterPos4sv
		/// Version: 1.0
		public void RasterPos4(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RasterPos4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.RasterPos4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.RasterPos4sv);
		}

		/// glReadBuffer
		/// Version: 1.0
		public void ReadBuffer(ReadBufferMode mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ReadBuffer);

			GLNative.ReadBuffer((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ReadBuffer);
		}

		/// glReadBuffer
		/// Version: 1.0
		public void ReadBuffer(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ReadBuffer);

			GLNative.ReadBuffer(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ReadBuffer);
		}

		/// glReadPixels
		/// Version: 1.0
		public void ReadPixels<T>(int x, int y, int width, int height, PixelFormat format, PixelType type, IntPtr pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ReadPixels);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.ReadPixels(x, y, width, height, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ReadPixels);
		}

		/// glReadPixels
		/// Version: 1.0
		public void ReadPixels<T>(int x, int y, int width, int height, uint format, uint type, out IntPtr pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ReadPixels);

			pixels = default(IntPtr);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.ReadPixels(x, y, width, height, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ReadPixels);
		}

		/// glRectd
		/// Version: 1.0
		public void Rect(double x1, double y1, double x2, double y2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectd);

			GLNative.Rectd(x1, y1, x2, y2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectd);
		}

		/// glRectdv
		/// Version: 1.0
		public void Rect(double[] v1, double[] v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectdv);

			unsafe
			{
				fixed (double* v1Ptr = v1)
				fixed (double* v2Ptr = v2)
				{
					GLNative.Rectdv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectdv);
		}

		/// glRectdv
		/// Version: 1.0
		public void Rect(ref double v1, ref double v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectdv);

			unsafe
			{
				fixed (double* v1Ptr = &v1)
				fixed (double* v2Ptr = &v2)
				{
					GLNative.Rectdv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectdv);
		}

		/// glRectf
		/// Version: 1.0
		public void Rect(float x1, float y1, float x2, float y2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectf);

			GLNative.Rectf(x1, y1, x2, y2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectf);
		}

		/// glRectfv
		/// Version: 1.0
		public void Rect(float[] v1, float[] v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectfv);

			unsafe
			{
				fixed (float* v1Ptr = v1)
				fixed (float* v2Ptr = v2)
				{
					GLNative.Rectfv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectfv);
		}

		/// glRectfv
		/// Version: 1.0
		public void Rect(ref float v1, ref float v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectfv);

			unsafe
			{
				fixed (float* v1Ptr = &v1)
				fixed (float* v2Ptr = &v2)
				{
					GLNative.Rectfv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectfv);
		}

		/// glRecti
		/// Version: 1.0
		public void Rect(int x1, int y1, int x2, int y2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Recti);

			GLNative.Recti(x1, y1, x2, y2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Recti);
		}

		/// glRectiv
		/// Version: 1.0
		public void Rect(int[] v1, int[] v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectiv);

			unsafe
			{
				fixed (int* v1Ptr = v1)
				fixed (int* v2Ptr = v2)
				{
					GLNative.Rectiv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectiv);
		}

		/// glRectiv
		/// Version: 1.0
		public void Rect(ref int v1, ref int v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectiv);

			unsafe
			{
				fixed (int* v1Ptr = &v1)
				fixed (int* v2Ptr = &v2)
				{
					GLNative.Rectiv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectiv);
		}

		/// glRects
		/// Version: 1.0
		public void Rect(short x1, short y1, short x2, short y2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rects);

			GLNative.Rects(x1, y1, x2, y2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Rects);
		}

		/// glRectsv
		/// Version: 1.0
		public void Rect(short[] v1, short[] v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectsv);

			unsafe
			{
				fixed (short* v1Ptr = v1)
				fixed (short* v2Ptr = v2)
				{
					GLNative.Rectsv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectsv);
		}

		/// glRectsv
		/// Version: 1.0
		public void Rect(ref short v1, ref short v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rectsv);

			unsafe
			{
				fixed (short* v1Ptr = &v1)
				fixed (short* v2Ptr = &v2)
				{
					GLNative.Rectsv(v1Ptr, v2Ptr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Rectsv);
		}

		private GLNative.RenderbufferStorage _RenderbufferStorage;

		/// glRenderbufferStorage
		/// Version: 3.0
		public void RenderbufferStorage(uint target, uint internalformat, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RenderbufferStorage);

			if (this._RenderbufferStorage == null)
				this._RenderbufferStorage = (GLNative.RenderbufferStorage)this.LoadExtensionFunction<GLNative.RenderbufferStorage>();

			this._RenderbufferStorage(target, internalformat, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.RenderbufferStorage);
		}

		private GLNative.RenderbufferStorageMultisample _RenderbufferStorageMultisample;

		/// glRenderbufferStorageMultisample
		/// Version: 3.0
		public void RenderbufferStorageMultisample(uint target, int samples, uint internalformat, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.RenderbufferStorageMultisample);

			if (this._RenderbufferStorageMultisample == null)
				this._RenderbufferStorageMultisample = (GLNative.RenderbufferStorageMultisample)this.LoadExtensionFunction<GLNative.RenderbufferStorageMultisample>();

			this._RenderbufferStorageMultisample(target, samples, internalformat, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.RenderbufferStorageMultisample);
		}

		/// glRenderMode
		/// Version: 1.0
		public int RenderMode(uint mode)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.RenderMode);

			result = GLNative.RenderMode(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.RenderMode);

			return result;
		}

		/// glRenderMode
		/// Version: 1.0
		public int RenderMode(RenderingMode mode)
		{
			int result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.RenderMode);

			result = GLNative.RenderMode((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.RenderMode);

			return result;
		}

		/// glRotated
		/// Version: 1.0
		public void Rotate(double angle, double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rotated);

			GLNative.Rotated(angle, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Rotated);
		}

		/// glRotatef
		/// Version: 1.0
		public void Rotate(float angle, float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Rotatef);

			GLNative.Rotatef(angle, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Rotatef);
		}

		private GLNative.SampleCoverage _SampleCoverage;

		/// glSampleCoverage
		/// Version: 1.3
		public void SampleCoverage(float value, bool invert)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SampleCoverage);

			if (this._SampleCoverage == null)
				this._SampleCoverage = (GLNative.SampleCoverage)this.LoadExtensionFunction<GLNative.SampleCoverage>();

			this._SampleCoverage(value, invert);

			this.AfterNativeFunctionCall(GLNativeFunctions.SampleCoverage);
		}

		private GLNative.SampleMaski _SampleMaski;

		/// glSampleMaski
		/// Version: 3.2
		public void SampleMask(uint index, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SampleMaski);

			if (this._SampleMaski == null)
				this._SampleMaski = (GLNative.SampleMaski)this.LoadExtensionFunction<GLNative.SampleMaski>();

			this._SampleMaski(index, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.SampleMaski);
		}

		private GLNative.SamplerParameterf _SamplerParameterf;

		/// glSamplerParameterf
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterf);

			if (this._SamplerParameterf == null)
				this._SamplerParameterf = (GLNative.SamplerParameterf)this.LoadExtensionFunction<GLNative.SamplerParameterf>();

			this._SamplerParameterf(sampler, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterf);
		}

		/// glSamplerParameterfv
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, ref float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterfv);

			unsafe
			{
				fixed (float* paramPtr = &param)
				{
					if (this._SamplerParameterfv == null)
						this._SamplerParameterfv = (GLNative.SamplerParameterfv)this.LoadExtensionFunction<GLNative.SamplerParameterfv>();

					this._SamplerParameterfv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterfv);
		}

		private GLNative.SamplerParameterfv _SamplerParameterfv;

		/// glSamplerParameterfv
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, float[] param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterfv);

			unsafe
			{
				fixed (float* paramPtr = param)
				{
					if (this._SamplerParameterfv == null)
						this._SamplerParameterfv = (GLNative.SamplerParameterfv)this.LoadExtensionFunction<GLNative.SamplerParameterfv>();

					this._SamplerParameterfv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterfv);
		}

		private GLNative.SamplerParameteri _SamplerParameteri;

		/// glSamplerParameteri
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameteri);

			if (this._SamplerParameteri == null)
				this._SamplerParameteri = (GLNative.SamplerParameteri)this.LoadExtensionFunction<GLNative.SamplerParameteri>();

			this._SamplerParameteri(sampler, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameteri);
		}

		private GLNative.SamplerParameterIiv _SamplerParameterIiv;

		/// glSamplerParameterIiv
		/// Version: 3.3
		public void SamplerParameterI(uint sampler, uint pname, int[] param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterIiv);

			unsafe
			{
				fixed (int* paramPtr = param)
				{
					if (this._SamplerParameterIiv == null)
						this._SamplerParameterIiv = (GLNative.SamplerParameterIiv)this.LoadExtensionFunction<GLNative.SamplerParameterIiv>();

					this._SamplerParameterIiv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterIiv);
		}

		/// glSamplerParameterIiv
		/// Version: 3.3
		public void SamplerParameterI(uint sampler, uint pname, ref int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterIiv);

			unsafe
			{
				fixed (int* paramPtr = &param)
				{
					if (this._SamplerParameterIiv == null)
						this._SamplerParameterIiv = (GLNative.SamplerParameterIiv)this.LoadExtensionFunction<GLNative.SamplerParameterIiv>();

					this._SamplerParameterIiv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterIiv);
		}

		/// glSamplerParameterIuiv
		/// Version: 3.3
		public void SamplerParameterI(uint sampler, uint pname, ref uint param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterIuiv);

			unsafe
			{
				fixed (uint* paramPtr = &param)
				{
					if (this._SamplerParameterIuiv == null)
						this._SamplerParameterIuiv = (GLNative.SamplerParameterIuiv)this.LoadExtensionFunction<GLNative.SamplerParameterIuiv>();

					this._SamplerParameterIuiv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterIuiv);
		}

		private GLNative.SamplerParameterIuiv _SamplerParameterIuiv;

		/// glSamplerParameterIuiv
		/// Version: 3.3
		public void SamplerParameterI(uint sampler, uint pname, uint[] param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameterIuiv);

			unsafe
			{
				fixed (uint* paramPtr = param)
				{
					if (this._SamplerParameterIuiv == null)
						this._SamplerParameterIuiv = (GLNative.SamplerParameterIuiv)this.LoadExtensionFunction<GLNative.SamplerParameterIuiv>();

					this._SamplerParameterIuiv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameterIuiv);
		}

		/// glSamplerParameteriv
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, ref int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameteriv);

			unsafe
			{
				fixed (int* paramPtr = &param)
				{
					if (this._SamplerParameteriv == null)
						this._SamplerParameteriv = (GLNative.SamplerParameteriv)this.LoadExtensionFunction<GLNative.SamplerParameteriv>();

					this._SamplerParameteriv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameteriv);
		}

		private GLNative.SamplerParameteriv _SamplerParameteriv;

		/// glSamplerParameteriv
		/// Version: 3.3
		public void SamplerParameter(uint sampler, uint pname, int[] param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SamplerParameteriv);

			unsafe
			{
				fixed (int* paramPtr = param)
				{
					if (this._SamplerParameteriv == null)
						this._SamplerParameteriv = (GLNative.SamplerParameteriv)this.LoadExtensionFunction<GLNative.SamplerParameteriv>();

					this._SamplerParameteriv(sampler, pname, paramPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SamplerParameteriv);
		}

		/// glScaled
		/// Version: 1.0
		public void Scale(double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Scaled);

			GLNative.Scaled(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Scaled);
		}

		/// glScalef
		/// Version: 1.0
		public void Scale(float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Scalef);

			GLNative.Scalef(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Scalef);
		}

		/// glScissor
		/// Version: 1.0
		public void Scissor(int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Scissor);

			GLNative.Scissor(x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.Scissor);
		}

		private GLNative.SecondaryColor3b _SecondaryColor3b;

		/// glSecondaryColor3b
		/// Version: 1.4
		public void SecondaryColor3(sbyte red, sbyte green, sbyte blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3b);

			if (this._SecondaryColor3b == null)
				this._SecondaryColor3b = (GLNative.SecondaryColor3b)this.LoadExtensionFunction<GLNative.SecondaryColor3b>();

			this._SecondaryColor3b(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3b);
		}

		private GLNative.SecondaryColor3bv _SecondaryColor3bv;

		/// glSecondaryColor3bv
		/// Version: 1.4
		public void SecondaryColor3(sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					if (this._SecondaryColor3bv == null)
						this._SecondaryColor3bv = (GLNative.SecondaryColor3bv)this.LoadExtensionFunction<GLNative.SecondaryColor3bv>();

					this._SecondaryColor3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3bv);
		}

		/// glSecondaryColor3bv
		/// Version: 1.4
		public void SecondaryColor3(ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					if (this._SecondaryColor3bv == null)
						this._SecondaryColor3bv = (GLNative.SecondaryColor3bv)this.LoadExtensionFunction<GLNative.SecondaryColor3bv>();

					this._SecondaryColor3bv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3bv);
		}

		private GLNative.SecondaryColor3d _SecondaryColor3d;

		/// glSecondaryColor3d
		/// Version: 1.4
		public void SecondaryColor3(double red, double green, double blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3d);

			if (this._SecondaryColor3d == null)
				this._SecondaryColor3d = (GLNative.SecondaryColor3d)this.LoadExtensionFunction<GLNative.SecondaryColor3d>();

			this._SecondaryColor3d(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3d);
		}

		private GLNative.SecondaryColor3dv _SecondaryColor3dv;

		/// glSecondaryColor3dv
		/// Version: 1.4
		public void SecondaryColor3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._SecondaryColor3dv == null)
						this._SecondaryColor3dv = (GLNative.SecondaryColor3dv)this.LoadExtensionFunction<GLNative.SecondaryColor3dv>();

					this._SecondaryColor3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3dv);
		}

		/// glSecondaryColor3dv
		/// Version: 1.4
		public void SecondaryColor3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._SecondaryColor3dv == null)
						this._SecondaryColor3dv = (GLNative.SecondaryColor3dv)this.LoadExtensionFunction<GLNative.SecondaryColor3dv>();

					this._SecondaryColor3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3dv);
		}

		private GLNative.SecondaryColor3f _SecondaryColor3f;

		/// glSecondaryColor3f
		/// Version: 1.4
		public void SecondaryColor3(float red, float green, float blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3f);

			if (this._SecondaryColor3f == null)
				this._SecondaryColor3f = (GLNative.SecondaryColor3f)this.LoadExtensionFunction<GLNative.SecondaryColor3f>();

			this._SecondaryColor3f(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3f);
		}

		/// glSecondaryColor3fv
		/// Version: 1.4
		public void SecondaryColor3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._SecondaryColor3fv == null)
						this._SecondaryColor3fv = (GLNative.SecondaryColor3fv)this.LoadExtensionFunction<GLNative.SecondaryColor3fv>();

					this._SecondaryColor3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3fv);
		}

		private GLNative.SecondaryColor3fv _SecondaryColor3fv;

		/// glSecondaryColor3fv
		/// Version: 1.4
		public void SecondaryColor3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._SecondaryColor3fv == null)
						this._SecondaryColor3fv = (GLNative.SecondaryColor3fv)this.LoadExtensionFunction<GLNative.SecondaryColor3fv>();

					this._SecondaryColor3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3fv);
		}

		private GLNative.SecondaryColor3i _SecondaryColor3i;

		/// glSecondaryColor3i
		/// Version: 1.4
		public void SecondaryColor3(int red, int green, int blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3i);

			if (this._SecondaryColor3i == null)
				this._SecondaryColor3i = (GLNative.SecondaryColor3i)this.LoadExtensionFunction<GLNative.SecondaryColor3i>();

			this._SecondaryColor3i(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3i);
		}

		/// glSecondaryColor3iv
		/// Version: 1.4
		public void SecondaryColor3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._SecondaryColor3iv == null)
						this._SecondaryColor3iv = (GLNative.SecondaryColor3iv)this.LoadExtensionFunction<GLNative.SecondaryColor3iv>();

					this._SecondaryColor3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3iv);
		}

		private GLNative.SecondaryColor3iv _SecondaryColor3iv;

		/// glSecondaryColor3iv
		/// Version: 1.4
		public void SecondaryColor3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._SecondaryColor3iv == null)
						this._SecondaryColor3iv = (GLNative.SecondaryColor3iv)this.LoadExtensionFunction<GLNative.SecondaryColor3iv>();

					this._SecondaryColor3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3iv);
		}

		private GLNative.SecondaryColor3s _SecondaryColor3s;

		/// glSecondaryColor3s
		/// Version: 1.4
		public void SecondaryColor3(short red, short green, short blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3s);

			if (this._SecondaryColor3s == null)
				this._SecondaryColor3s = (GLNative.SecondaryColor3s)this.LoadExtensionFunction<GLNative.SecondaryColor3s>();

			this._SecondaryColor3s(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3s);
		}

		private GLNative.SecondaryColor3sv _SecondaryColor3sv;

		/// glSecondaryColor3sv
		/// Version: 1.4
		public void SecondaryColor3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._SecondaryColor3sv == null)
						this._SecondaryColor3sv = (GLNative.SecondaryColor3sv)this.LoadExtensionFunction<GLNative.SecondaryColor3sv>();

					this._SecondaryColor3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3sv);
		}

		/// glSecondaryColor3sv
		/// Version: 1.4
		public void SecondaryColor3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._SecondaryColor3sv == null)
						this._SecondaryColor3sv = (GLNative.SecondaryColor3sv)this.LoadExtensionFunction<GLNative.SecondaryColor3sv>();

					this._SecondaryColor3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3sv);
		}

		private GLNative.SecondaryColor3ub _SecondaryColor3ub;

		/// glSecondaryColor3ub
		/// Version: 1.4
		public void SecondaryColor3u(byte red, byte green, byte blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3ub);

			if (this._SecondaryColor3ub == null)
				this._SecondaryColor3ub = (GLNative.SecondaryColor3ub)this.LoadExtensionFunction<GLNative.SecondaryColor3ub>();

			this._SecondaryColor3ub(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3ub);
		}

		/// glSecondaryColor3ubv
		/// Version: 1.4
		public void SecondaryColor3(ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3ubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					if (this._SecondaryColor3ubv == null)
						this._SecondaryColor3ubv = (GLNative.SecondaryColor3ubv)this.LoadExtensionFunction<GLNative.SecondaryColor3ubv>();

					this._SecondaryColor3ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3ubv);
		}

		private GLNative.SecondaryColor3ubv _SecondaryColor3ubv;

		/// glSecondaryColor3ubv
		/// Version: 1.4
		public void SecondaryColor3(byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3ubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					if (this._SecondaryColor3ubv == null)
						this._SecondaryColor3ubv = (GLNative.SecondaryColor3ubv)this.LoadExtensionFunction<GLNative.SecondaryColor3ubv>();

					this._SecondaryColor3ubv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3ubv);
		}

		private GLNative.SecondaryColor3ui _SecondaryColor3ui;

		/// glSecondaryColor3ui
		/// Version: 1.4
		public void SecondaryColor3(uint red, uint green, uint blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3ui);

			if (this._SecondaryColor3ui == null)
				this._SecondaryColor3ui = (GLNative.SecondaryColor3ui)this.LoadExtensionFunction<GLNative.SecondaryColor3ui>();

			this._SecondaryColor3ui(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3ui);
		}

		/// glSecondaryColor3uiv
		/// Version: 1.4
		public void SecondaryColor3(ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._SecondaryColor3uiv == null)
						this._SecondaryColor3uiv = (GLNative.SecondaryColor3uiv)this.LoadExtensionFunction<GLNative.SecondaryColor3uiv>();

					this._SecondaryColor3uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3uiv);
		}

		private GLNative.SecondaryColor3uiv _SecondaryColor3uiv;

		/// glSecondaryColor3uiv
		/// Version: 1.4
		public void SecondaryColor3(uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._SecondaryColor3uiv == null)
						this._SecondaryColor3uiv = (GLNative.SecondaryColor3uiv)this.LoadExtensionFunction<GLNative.SecondaryColor3uiv>();

					this._SecondaryColor3uiv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3uiv);
		}

		private GLNative.SecondaryColor3us _SecondaryColor3us;

		/// glSecondaryColor3us
		/// Version: 1.4
		public void SecondaryColor3u(ushort red, ushort green, ushort blue)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3us);

			if (this._SecondaryColor3us == null)
				this._SecondaryColor3us = (GLNative.SecondaryColor3us)this.LoadExtensionFunction<GLNative.SecondaryColor3us>();

			this._SecondaryColor3us(red, green, blue);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3us);
		}

		/// glSecondaryColor3usv
		/// Version: 1.4
		public void SecondaryColor3(ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3usv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					if (this._SecondaryColor3usv == null)
						this._SecondaryColor3usv = (GLNative.SecondaryColor3usv)this.LoadExtensionFunction<GLNative.SecondaryColor3usv>();

					this._SecondaryColor3usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3usv);
		}

		private GLNative.SecondaryColor3usv _SecondaryColor3usv;

		/// glSecondaryColor3usv
		/// Version: 1.4
		public void SecondaryColor3(ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColor3usv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					if (this._SecondaryColor3usv == null)
						this._SecondaryColor3usv = (GLNative.SecondaryColor3usv)this.LoadExtensionFunction<GLNative.SecondaryColor3usv>();

					this._SecondaryColor3usv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColor3usv);
		}

		private GLNative.SecondaryColorP3ui _SecondaryColorP3ui;

		/// glSecondaryColorP3ui
		/// Version: 3.3
		public void SecondaryColorP3(uint type, uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorP3ui);

			if (this._SecondaryColorP3ui == null)
				this._SecondaryColorP3ui = (GLNative.SecondaryColorP3ui)this.LoadExtensionFunction<GLNative.SecondaryColorP3ui>();

			this._SecondaryColorP3ui(type, color);

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorP3ui);
		}

		/// glSecondaryColorP3uiv
		/// Version: 3.3
		public void SecondaryColorP3(uint type, ref uint color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorP3uiv);

			unsafe
			{
				fixed (uint* colorPtr = &color)
				{
					if (this._SecondaryColorP3uiv == null)
						this._SecondaryColorP3uiv = (GLNative.SecondaryColorP3uiv)this.LoadExtensionFunction<GLNative.SecondaryColorP3uiv>();

					this._SecondaryColorP3uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorP3uiv);
		}

		private GLNative.SecondaryColorP3uiv _SecondaryColorP3uiv;

		/// glSecondaryColorP3uiv
		/// Version: 3.3
		public void SecondaryColorP3(uint type, uint[] color)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorP3uiv);

			unsafe
			{
				fixed (uint* colorPtr = color)
				{
					if (this._SecondaryColorP3uiv == null)
						this._SecondaryColorP3uiv = (GLNative.SecondaryColorP3uiv)this.LoadExtensionFunction<GLNative.SecondaryColorP3uiv>();

					this._SecondaryColorP3uiv(type, colorPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorP3uiv);
		}

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer<T>(int size, ColorPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._SecondaryColorPointer == null)
						this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

					this._SecondaryColorPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer(int size, ColorPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				if (this._SecondaryColorPointer == null)
					this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

				this._SecondaryColorPointer(size, (uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer<T>(int size, ColorPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._SecondaryColorPointer == null)
						this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

					this._SecondaryColorPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer(int size, uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				if (this._SecondaryColorPointer == null)
					this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

				this._SecondaryColorPointer(size, type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer<T>(int size, uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._SecondaryColorPointer == null)
						this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

					this._SecondaryColorPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		private GLNative.SecondaryColorPointer _SecondaryColorPointer;

		/// glSecondaryColorPointer
		/// Version: 1.4
		public void SecondaryColorPointer<T>(int size, uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._SecondaryColorPointer == null)
						this._SecondaryColorPointer = (GLNative.SecondaryColorPointer)this.LoadExtensionFunction<GLNative.SecondaryColorPointer>();

					this._SecondaryColorPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SecondaryColorPointer);
		}

		/// glSelectBuffer
		/// Version: 1.0
		public void SelectBuffer(int size, uint[] buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SelectBuffer);

			unsafe
			{
				fixed (uint* bufferPtr = buffer)
				{
					GLNative.SelectBuffer(size, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SelectBuffer);
		}

		/// glSelectBuffer
		/// Version: 1.0
		public void SelectBuffer(int size, out uint buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.SelectBuffer);

			unsafe
			{
				fixed (uint* bufferPtr = &buffer)
				{
					GLNative.SelectBuffer(size, bufferPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.SelectBuffer);
		}

		/// glShadeModel
		/// Version: 1.0
		public void ShadeModel(ShadingModel mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ShadeModel);

			GLNative.ShadeModel((uint)mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ShadeModel);
		}

		/// glShadeModel
		/// Version: 1.0
		public void ShadeModel(uint mode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ShadeModel);

			GLNative.ShadeModel(mode);

			this.AfterNativeFunctionCall(GLNativeFunctions.ShadeModel);
		}

		/// glShaderSource
		/// Version: 2.0
		public void ShaderSource(uint shader, int count, string[] @string, ref int length)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ShaderSource);

			unsafe
			{
				fixed (int* lengthPtr = &length)
				{
					if (this._ShaderSource == null)
						this._ShaderSource = (GLNative.ShaderSource)this.LoadExtensionFunction<GLNative.ShaderSource>();

					this._ShaderSource(shader, count, @string, lengthPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ShaderSource);
		}

		private GLNative.ShaderSource _ShaderSource;

		/// glShaderSource
		/// Version: 2.0
		public void ShaderSource(uint shader, int count, string[] @string, int[] length)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ShaderSource);

			unsafe
			{
				fixed (int* lengthPtr = length)
				{
					if (this._ShaderSource == null)
						this._ShaderSource = (GLNative.ShaderSource)this.LoadExtensionFunction<GLNative.ShaderSource>();

					this._ShaderSource(shader, count, @string, lengthPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.ShaderSource);
		}

		/// glStencilFunc
		/// Version: 1.0
		public void StencilFunc(StencilFunction func, int @ref, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilFunc);

			GLNative.StencilFunc((uint)func, @ref, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilFunc);
		}

		/// glStencilFunc
		/// Version: 1.0
		public void StencilFunc(uint func, int @ref, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilFunc);

			GLNative.StencilFunc(func, @ref, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilFunc);
		}

		/// glStencilFuncSeparate
		/// Version: 2.0
		public void StencilFuncSeparate(uint face, StencilFunction func, int @ref, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilFuncSeparate);

			if (this._StencilFuncSeparate == null)
				this._StencilFuncSeparate = (GLNative.StencilFuncSeparate)this.LoadExtensionFunction<GLNative.StencilFuncSeparate>();

			this._StencilFuncSeparate(face, (uint)func, @ref, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilFuncSeparate);
		}

		private GLNative.StencilFuncSeparate _StencilFuncSeparate;

		/// glStencilFuncSeparate
		/// Version: 2.0
		public void StencilFuncSeparate(uint face, uint func, int @ref, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilFuncSeparate);

			if (this._StencilFuncSeparate == null)
				this._StencilFuncSeparate = (GLNative.StencilFuncSeparate)this.LoadExtensionFunction<GLNative.StencilFuncSeparate>();

			this._StencilFuncSeparate(face, func, @ref, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilFuncSeparate);
		}

		/// glStencilMask
		/// Version: 1.0
		public void StencilMask(uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilMask);

			GLNative.StencilMask(mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilMask);
		}

		private GLNative.StencilMaskSeparate _StencilMaskSeparate;

		/// glStencilMaskSeparate
		/// Version: 2.0
		public void StencilMaskSeparate(uint face, uint mask)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilMaskSeparate);

			if (this._StencilMaskSeparate == null)
				this._StencilMaskSeparate = (GLNative.StencilMaskSeparate)this.LoadExtensionFunction<GLNative.StencilMaskSeparate>();

			this._StencilMaskSeparate(face, mask);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilMaskSeparate);
		}

		/// glStencilOp
		/// Version: 1.0
		public void StencilOp(uint fail, uint zfail, uint zpass)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilOp);

			GLNative.StencilOp(fail, zfail, zpass);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilOp);
		}

		/// glStencilOp
		/// Version: 1.0
		public void StencilOp(StencilOp fail, StencilOp zfail, StencilOp zpass)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilOp);

			GLNative.StencilOp((uint)fail, (uint)zfail, (uint)zpass);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilOp);
		}

		private GLNative.StencilOpSeparate _StencilOpSeparate;

		/// glStencilOpSeparate
		/// Version: 2.0
		public void StencilOpSeparate(uint face, uint sfail, uint dpfail, uint dppass)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilOpSeparate);

			if (this._StencilOpSeparate == null)
				this._StencilOpSeparate = (GLNative.StencilOpSeparate)this.LoadExtensionFunction<GLNative.StencilOpSeparate>();

			this._StencilOpSeparate(face, sfail, dpfail, dppass);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilOpSeparate);
		}

		/// glStencilOpSeparate
		/// Version: 2.0
		public void StencilOpSeparate(uint face, StencilOp sfail, StencilOp dpfail, StencilOp dppass)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.StencilOpSeparate);

			if (this._StencilOpSeparate == null)
				this._StencilOpSeparate = (GLNative.StencilOpSeparate)this.LoadExtensionFunction<GLNative.StencilOpSeparate>();

			this._StencilOpSeparate(face, (uint)sfail, (uint)dpfail, (uint)dppass);

			this.AfterNativeFunctionCall(GLNativeFunctions.StencilOpSeparate);
		}

		private GLNative.TexBuffer _TexBuffer;

		/// glTexBuffer
		/// Version: 3.1
		public void TexBuffer(uint target, uint internalformat, uint buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexBuffer);

			if (this._TexBuffer == null)
				this._TexBuffer = (GLNative.TexBuffer)this.LoadExtensionFunction<GLNative.TexBuffer>();

			this._TexBuffer(target, internalformat, buffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexBuffer);
		}

		/// glTexBuffer
		/// Version: 3.1
		public void TexBuffer(TextureTarget target, uint internalformat, uint buffer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexBuffer);

			if (this._TexBuffer == null)
				this._TexBuffer = (GLNative.TexBuffer)this.LoadExtensionFunction<GLNative.TexBuffer>();

			this._TexBuffer((uint)target, internalformat, buffer);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexBuffer);
		}

		/// glTexCoord1d
		/// Version: 1.0
		public void TexCoord1(double s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1d);

			GLNative.TexCoord1d(s);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1d);
		}

		/// glTexCoord1dv
		/// Version: 1.0
		public void TexCoord1(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.TexCoord1dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1dv);
		}

		/// glTexCoord1dv
		/// Version: 1.0
		public void TexCoord1(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.TexCoord1dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1dv);
		}

		/// glTexCoord1f
		/// Version: 1.0
		public void TexCoord1(float s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1f);

			GLNative.TexCoord1f(s);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1f);
		}

		/// glTexCoord1fv
		/// Version: 1.0
		public void TexCoord1(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.TexCoord1fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1fv);
		}

		/// glTexCoord1fv
		/// Version: 1.0
		public void TexCoord1(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.TexCoord1fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1fv);
		}

		/// glTexCoord1i
		/// Version: 1.0
		public void TexCoord1(int s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1i);

			GLNative.TexCoord1i(s);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1i);
		}

		/// glTexCoord1iv
		/// Version: 1.0
		public void TexCoord1(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.TexCoord1iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1iv);
		}

		/// glTexCoord1iv
		/// Version: 1.0
		public void TexCoord1(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.TexCoord1iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1iv);
		}

		/// glTexCoord1s
		/// Version: 1.0
		public void TexCoord1(short s)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1s);

			GLNative.TexCoord1s(s);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1s);
		}

		/// glTexCoord1sv
		/// Version: 1.0
		public void TexCoord1(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.TexCoord1sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1sv);
		}

		/// glTexCoord1sv
		/// Version: 1.0
		public void TexCoord1(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord1sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.TexCoord1sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord1sv);
		}

		/// glTexCoord2d
		/// Version: 1.0
		public void TexCoord2(double s, double t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2d);

			GLNative.TexCoord2d(s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2d);
		}

		/// glTexCoord2dv
		/// Version: 1.0
		public void TexCoord2(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.TexCoord2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2dv);
		}

		/// glTexCoord2dv
		/// Version: 1.0
		public void TexCoord2(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.TexCoord2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2dv);
		}

		/// glTexCoord2f
		/// Version: 1.0
		public void TexCoord2(float s, float t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2f);

			GLNative.TexCoord2f(s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2f);
		}

		/// glTexCoord2fv
		/// Version: 1.0
		public void TexCoord2(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.TexCoord2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2fv);
		}

		/// glTexCoord2fv
		/// Version: 1.0
		public void TexCoord2(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.TexCoord2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2fv);
		}

		/// glTexCoord2i
		/// Version: 1.0
		public void TexCoord2(int s, int t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2i);

			GLNative.TexCoord2i(s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2i);
		}

		/// glTexCoord2iv
		/// Version: 1.0
		public void TexCoord2(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.TexCoord2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2iv);
		}

		/// glTexCoord2iv
		/// Version: 1.0
		public void TexCoord2(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.TexCoord2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2iv);
		}

		/// glTexCoord2s
		/// Version: 1.0
		public void TexCoord2(short s, short t)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2s);

			GLNative.TexCoord2s(s, t);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2s);
		}

		/// glTexCoord2sv
		/// Version: 1.0
		public void TexCoord2(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.TexCoord2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2sv);
		}

		/// glTexCoord2sv
		/// Version: 1.0
		public void TexCoord2(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.TexCoord2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord2sv);
		}

		/// glTexCoord3d
		/// Version: 1.0
		public void TexCoord3(double s, double t, double r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3d);

			GLNative.TexCoord3d(s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3d);
		}

		/// glTexCoord3dv
		/// Version: 1.0
		public void TexCoord3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.TexCoord3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3dv);
		}

		/// glTexCoord3dv
		/// Version: 1.0
		public void TexCoord3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.TexCoord3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3dv);
		}

		/// glTexCoord3f
		/// Version: 1.0
		public void TexCoord3(float s, float t, float r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3f);

			GLNative.TexCoord3f(s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3f);
		}

		/// glTexCoord3fv
		/// Version: 1.0
		public void TexCoord3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.TexCoord3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3fv);
		}

		/// glTexCoord3fv
		/// Version: 1.0
		public void TexCoord3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.TexCoord3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3fv);
		}

		/// glTexCoord3i
		/// Version: 1.0
		public void TexCoord3(int s, int t, int r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3i);

			GLNative.TexCoord3i(s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3i);
		}

		/// glTexCoord3iv
		/// Version: 1.0
		public void TexCoord3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.TexCoord3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3iv);
		}

		/// glTexCoord3iv
		/// Version: 1.0
		public void TexCoord3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.TexCoord3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3iv);
		}

		/// glTexCoord3s
		/// Version: 1.0
		public void TexCoord3(short s, short t, short r)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3s);

			GLNative.TexCoord3s(s, t, r);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3s);
		}

		/// glTexCoord3sv
		/// Version: 1.0
		public void TexCoord3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.TexCoord3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3sv);
		}

		/// glTexCoord3sv
		/// Version: 1.0
		public void TexCoord3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.TexCoord3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord3sv);
		}

		/// glTexCoord4d
		/// Version: 1.0
		public void TexCoord4(double s, double t, double r, double q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4d);

			GLNative.TexCoord4d(s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4d);
		}

		/// glTexCoord4dv
		/// Version: 1.0
		public void TexCoord4(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.TexCoord4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4dv);
		}

		/// glTexCoord4dv
		/// Version: 1.0
		public void TexCoord4(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.TexCoord4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4dv);
		}

		/// glTexCoord4f
		/// Version: 1.0
		public void TexCoord4(float s, float t, float r, float q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4f);

			GLNative.TexCoord4f(s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4f);
		}

		/// glTexCoord4fv
		/// Version: 1.0
		public void TexCoord4(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.TexCoord4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4fv);
		}

		/// glTexCoord4fv
		/// Version: 1.0
		public void TexCoord4(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.TexCoord4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4fv);
		}

		/// glTexCoord4i
		/// Version: 1.0
		public void TexCoord4(int s, int t, int r, int q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4i);

			GLNative.TexCoord4i(s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4i);
		}

		/// glTexCoord4iv
		/// Version: 1.0
		public void TexCoord4(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.TexCoord4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4iv);
		}

		/// glTexCoord4iv
		/// Version: 1.0
		public void TexCoord4(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.TexCoord4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4iv);
		}

		/// glTexCoord4s
		/// Version: 1.0
		public void TexCoord4(short s, short t, short r, short q)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4s);

			GLNative.TexCoord4s(s, t, r, q);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4s);
		}

		/// glTexCoord4sv
		/// Version: 1.0
		public void TexCoord4(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.TexCoord4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4sv);
		}

		/// glTexCoord4sv
		/// Version: 1.0
		public void TexCoord4(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoord4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.TexCoord4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoord4sv);
		}

		private GLNative.TexCoordP1ui _TexCoordP1ui;

		/// glTexCoordP1ui
		/// Version: 3.3
		public void TexCoordP1(uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP1ui);

			if (this._TexCoordP1ui == null)
				this._TexCoordP1ui = (GLNative.TexCoordP1ui)this.LoadExtensionFunction<GLNative.TexCoordP1ui>();

			this._TexCoordP1ui(type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP1ui);
		}

		/// glTexCoordP1uiv
		/// Version: 3.3
		public void TexCoordP1(uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP1uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._TexCoordP1uiv == null)
						this._TexCoordP1uiv = (GLNative.TexCoordP1uiv)this.LoadExtensionFunction<GLNative.TexCoordP1uiv>();

					this._TexCoordP1uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP1uiv);
		}

		private GLNative.TexCoordP1uiv _TexCoordP1uiv;

		/// glTexCoordP1uiv
		/// Version: 3.3
		public void TexCoordP1(uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP1uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._TexCoordP1uiv == null)
						this._TexCoordP1uiv = (GLNative.TexCoordP1uiv)this.LoadExtensionFunction<GLNative.TexCoordP1uiv>();

					this._TexCoordP1uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP1uiv);
		}

		private GLNative.TexCoordP2ui _TexCoordP2ui;

		/// glTexCoordP2ui
		/// Version: 3.3
		public void TexCoordP2(uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP2ui);

			if (this._TexCoordP2ui == null)
				this._TexCoordP2ui = (GLNative.TexCoordP2ui)this.LoadExtensionFunction<GLNative.TexCoordP2ui>();

			this._TexCoordP2ui(type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP2ui);
		}

		/// glTexCoordP2uiv
		/// Version: 3.3
		public void TexCoordP2(uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP2uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._TexCoordP2uiv == null)
						this._TexCoordP2uiv = (GLNative.TexCoordP2uiv)this.LoadExtensionFunction<GLNative.TexCoordP2uiv>();

					this._TexCoordP2uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP2uiv);
		}

		private GLNative.TexCoordP2uiv _TexCoordP2uiv;

		/// glTexCoordP2uiv
		/// Version: 3.3
		public void TexCoordP2(uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP2uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._TexCoordP2uiv == null)
						this._TexCoordP2uiv = (GLNative.TexCoordP2uiv)this.LoadExtensionFunction<GLNative.TexCoordP2uiv>();

					this._TexCoordP2uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP2uiv);
		}

		private GLNative.TexCoordP3ui _TexCoordP3ui;

		/// glTexCoordP3ui
		/// Version: 3.3
		public void TexCoordP3(uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP3ui);

			if (this._TexCoordP3ui == null)
				this._TexCoordP3ui = (GLNative.TexCoordP3ui)this.LoadExtensionFunction<GLNative.TexCoordP3ui>();

			this._TexCoordP3ui(type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP3ui);
		}

		private GLNative.TexCoordP3uiv _TexCoordP3uiv;

		/// glTexCoordP3uiv
		/// Version: 3.3
		public void TexCoordP3(uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._TexCoordP3uiv == null)
						this._TexCoordP3uiv = (GLNative.TexCoordP3uiv)this.LoadExtensionFunction<GLNative.TexCoordP3uiv>();

					this._TexCoordP3uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP3uiv);
		}

		/// glTexCoordP3uiv
		/// Version: 3.3
		public void TexCoordP3(uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP3uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._TexCoordP3uiv == null)
						this._TexCoordP3uiv = (GLNative.TexCoordP3uiv)this.LoadExtensionFunction<GLNative.TexCoordP3uiv>();

					this._TexCoordP3uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP3uiv);
		}

		private GLNative.TexCoordP4ui _TexCoordP4ui;

		/// glTexCoordP4ui
		/// Version: 3.3
		public void TexCoordP4(uint type, uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP4ui);

			if (this._TexCoordP4ui == null)
				this._TexCoordP4ui = (GLNative.TexCoordP4ui)this.LoadExtensionFunction<GLNative.TexCoordP4ui>();

			this._TexCoordP4ui(type, coords);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP4ui);
		}

		private GLNative.TexCoordP4uiv _TexCoordP4uiv;

		/// glTexCoordP4uiv
		/// Version: 3.3
		public void TexCoordP4(uint type, uint[] coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP4uiv);

			unsafe
			{
				fixed (uint* coordsPtr = coords)
				{
					if (this._TexCoordP4uiv == null)
						this._TexCoordP4uiv = (GLNative.TexCoordP4uiv)this.LoadExtensionFunction<GLNative.TexCoordP4uiv>();

					this._TexCoordP4uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP4uiv);
		}

		/// glTexCoordP4uiv
		/// Version: 3.3
		public void TexCoordP4(uint type, ref uint coords)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordP4uiv);

			unsafe
			{
				fixed (uint* coordsPtr = &coords)
				{
					if (this._TexCoordP4uiv == null)
						this._TexCoordP4uiv = (GLNative.TexCoordP4uiv)this.LoadExtensionFunction<GLNative.TexCoordP4uiv>();

					this._TexCoordP4uiv(type, coordsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordP4uiv);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer<T>(int size, TexCoordPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.TexCoordPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer<T>(int size, uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.TexCoordPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer(int size, uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GLNative.TexCoordPointer(size, type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer(int size, TexCoordPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GLNative.TexCoordPointer(size, (uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer<T>(int size, TexCoordPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.TexCoordPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexCoordPointer
		/// Version: 1.1
		public void TexCoordPointer<T>(int size, uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexCoordPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.TexCoordPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexCoordPointer);
		}

		/// glTexEnvf
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvf);

			GLNative.TexEnvf(target, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvf);
		}

		/// glTexEnvf
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvf);

			GLNative.TexEnvf((uint)target, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvf);
		}

		/// glTexEnvfv
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexEnvfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvfv);
		}

		/// glTexEnvfv
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexEnvfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvfv);
		}

		/// glTexEnvfv
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexEnvfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvfv);
		}

		/// glTexEnvfv
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexEnvfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvfv);
		}

		/// glTexEnvi
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvi);

			GLNative.TexEnvi((uint)target, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvi);
		}

		/// glTexEnvi
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnvi);

			GLNative.TexEnvi(target, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnvi);
		}

		/// glTexEnviv
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexEnviv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnviv);
		}

		/// glTexEnviv
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexEnviv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnviv);
		}

		/// glTexEnviv
		/// Version: 1.0
		public void TexEnv(TextureEnvTarget target, TextureEnvParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexEnviv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnviv);
		}

		/// glTexEnviv
		/// Version: 1.0
		public void TexEnv(uint target, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexEnviv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexEnviv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexEnviv);
		}

		/// glTexGend
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, double param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGend);

			GLNative.TexGend((uint)coord, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGend);
		}

		/// glTexGend
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, double param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGend);

			GLNative.TexGend(coord, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGend);
		}

		/// glTexGendv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, ref double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.TexGendv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGendv);
		}

		/// glTexGendv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.TexGendv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGendv);
		}

		/// glTexGendv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, ref double @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = &@params)
				{
					GLNative.TexGendv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGendv);
		}

		/// glTexGendv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, double[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGendv);

			unsafe
			{
				fixed (double* @paramsPtr = @params)
				{
					GLNative.TexGendv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGendv);
		}

		/// glTexGenf
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenf);

			GLNative.TexGenf((uint)coord, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenf);
		}

		/// glTexGenf
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenf);

			GLNative.TexGenf(coord, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenf);
		}

		/// glTexGenfv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexGenfv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenfv);
		}

		/// glTexGenfv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexGenfv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenfv);
		}

		/// glTexGenfv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexGenfv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenfv);
		}

		/// glTexGenfv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGenfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexGenfv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGenfv);
		}

		/// glTexGeni
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeni);

			GLNative.TexGeni((uint)coord, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeni);
		}

		/// glTexGeni
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeni);

			GLNative.TexGeni(coord, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeni);
		}

		/// glTexGeniv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexGeniv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeniv);
		}

		/// glTexGeniv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexGeniv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeniv);
		}

		/// glTexGeniv
		/// Version: 1.0
		public void TexGen(uint coord, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexGeniv(coord, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeniv);
		}

		/// glTexGeniv
		/// Version: 1.0
		public void TexGen(TextureCoordName coord, TextureGenParameter pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexGeniv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexGeniv((uint)coord, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexGeniv);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D<T>(uint target, int level, int internalformat, int width, int border, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage1D(target, level, internalformat, width, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D<T>(TextureTarget target, int level, int internalformat, int width, int border, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage1D((uint)target, level, internalformat, width, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D<T>(uint target, int level, int internalformat, int width, int border, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage1D(target, level, internalformat, width, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D(uint target, int level, int internalformat, int width, int border, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GLNative.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D<T>(TextureTarget target, int level, int internalformat, int width, int border, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage1D((uint)target, level, internalformat, width, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage1D
		/// Version: 1.0
		public void TexImage1D(TextureTarget target, int level, int internalformat, int width, int border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage1D);

			unsafe
			{
				GLNative.TexImage1D((uint)target, level, internalformat, width, border, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage1D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D<T>(uint target, int level, int internalformat, int width, int height, int border, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage2D(target, level, internalformat, width, height, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D<T>(uint target, int level, int internalformat, int width, int height, int border, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage2D(target, level, internalformat, width, height, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D(uint target, int level, int internalformat, int width, int height, int border, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GLNative.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D<T>(TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage2D((uint)target, level, internalformat, width, height, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D(TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GLNative.TexImage2D((uint)target, level, internalformat, width, height, border, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		/// glTexImage2D
		/// Version: 1.0
		public void TexImage2D<T>(TextureTarget target, int level, int internalformat, int width, int height, int border, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexImage2D((uint)target, level, internalformat, width, height, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2D);
		}

		private GLNative.TexImage2DMultisample _TexImage2DMultisample;

		/// glTexImage2DMultisample
		/// Version: 3.2
		public void TexImage2DMultisample(uint target, int samples, int internalformat, int width, int height, bool fixedsamplelocations)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage2DMultisample);

			if (this._TexImage2DMultisample == null)
				this._TexImage2DMultisample = (GLNative.TexImage2DMultisample)this.LoadExtensionFunction<GLNative.TexImage2DMultisample>();

			this._TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage2DMultisample);
		}

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D(TextureTarget target, int level, int internalformat, int width, int height, int depth, int border, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				if (this._TexImage3D == null)
					this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

				this._TexImage3D((uint)target, level, internalformat, width, height, depth, border, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D<T>(TextureTarget target, int level, int internalformat, int width, int height, int depth, int border, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexImage3D == null)
						this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

					this._TexImage3D((uint)target, level, internalformat, width, height, depth, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D(uint target, int level, int internalformat, int width, int height, int depth, int border, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				if (this._TexImage3D == null)
					this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

				this._TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D<T>(uint target, int level, int internalformat, int width, int height, int depth, int border, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexImage3D == null)
						this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

					this._TexImage3D(target, level, internalformat, width, height, depth, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		private GLNative.TexImage3D _TexImage3D;

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D<T>(uint target, int level, int internalformat, int width, int height, int depth, int border, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexImage3D == null)
						this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

					this._TexImage3D(target, level, internalformat, width, height, depth, border, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		/// glTexImage3D
		/// Version: 1.2
		public void TexImage3D<T>(TextureTarget target, int level, int internalformat, int width, int height, int depth, int border, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexImage3D == null)
						this._TexImage3D = (GLNative.TexImage3D)this.LoadExtensionFunction<GLNative.TexImage3D>();

					this._TexImage3D((uint)target, level, internalformat, width, height, depth, border, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3D);
		}

		private GLNative.TexImage3DMultisample _TexImage3DMultisample;

		/// glTexImage3DMultisample
		/// Version: 3.2
		public void TexImage3DMultisample(uint target, int samples, int internalformat, int width, int height, int depth, bool fixedsamplelocations)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexImage3DMultisample);

			if (this._TexImage3DMultisample == null)
				this._TexImage3DMultisample = (GLNative.TexImage3DMultisample)this.LoadExtensionFunction<GLNative.TexImage3DMultisample>();

			this._TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexImage3DMultisample);
		}

		/// glTexParameterf
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterf);

			GLNative.TexParameterf(target, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterf);
		}

		/// glTexParameterf
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, float param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterf);

			GLNative.TexParameterf((uint)target, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterf);
		}

		/// glTexParameterfv
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexParameterfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterfv);
		}

		/// glTexParameterfv
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, ref float @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = &@params)
				{
					GLNative.TexParameterfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterfv);
		}

		/// glTexParameterfv
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexParameterfv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterfv);
		}

		/// glTexParameterfv
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, float[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterfv);

			unsafe
			{
				fixed (float* @paramsPtr = @params)
				{
					GLNative.TexParameterfv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterfv);
		}

		/// glTexParameteri
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteri);

			GLNative.TexParameteri((uint)target, (uint)pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteri);
		}

		/// glTexParameteri
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, int param)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteri);

			GLNative.TexParameteri(target, pname, param);

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteri);
		}

		private GLNative.TexParameterIiv _TexParameterIiv;

		/// glTexParameterIiv
		/// Version: 3.0
		public void TexParameterI(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._TexParameterIiv == null)
						this._TexParameterIiv = (GLNative.TexParameterIiv)this.LoadExtensionFunction<GLNative.TexParameterIiv>();

					this._TexParameterIiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIiv);
		}

		/// glTexParameterIiv
		/// Version: 3.0
		public void TexParameterI(TextureTarget target, TextureParameterName pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					if (this._TexParameterIiv == null)
						this._TexParameterIiv = (GLNative.TexParameterIiv)this.LoadExtensionFunction<GLNative.TexParameterIiv>();

					this._TexParameterIiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIiv);
		}

		/// glTexParameterIiv
		/// Version: 3.0
		public void TexParameterI(TextureTarget target, TextureParameterName pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._TexParameterIiv == null)
						this._TexParameterIiv = (GLNative.TexParameterIiv)this.LoadExtensionFunction<GLNative.TexParameterIiv>();

					this._TexParameterIiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIiv);
		}

		/// glTexParameterIiv
		/// Version: 3.0
		public void TexParameterI(uint target, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIiv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					if (this._TexParameterIiv == null)
						this._TexParameterIiv = (GLNative.TexParameterIiv)this.LoadExtensionFunction<GLNative.TexParameterIiv>();

					this._TexParameterIiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIiv);
		}

		/// glTexParameterIuiv
		/// Version: 3.0
		public void TexParameterI(TextureTarget target, TextureParameterName pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._TexParameterIuiv == null)
						this._TexParameterIuiv = (GLNative.TexParameterIuiv)this.LoadExtensionFunction<GLNative.TexParameterIuiv>();

					this._TexParameterIuiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);
		}

		private GLNative.TexParameterIuiv _TexParameterIuiv;

		/// glTexParameterIuiv
		/// Version: 3.0
		public void TexParameterI(uint target, uint pname, uint[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = @params)
				{
					if (this._TexParameterIuiv == null)
						this._TexParameterIuiv = (GLNative.TexParameterIuiv)this.LoadExtensionFunction<GLNative.TexParameterIuiv>();

					this._TexParameterIuiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);
		}

		/// glTexParameterIuiv
		/// Version: 3.0
		public void TexParameterI(TextureTarget target, TextureParameterName pname, ref uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._TexParameterIuiv == null)
						this._TexParameterIuiv = (GLNative.TexParameterIuiv)this.LoadExtensionFunction<GLNative.TexParameterIuiv>();

					this._TexParameterIuiv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);
		}

		/// glTexParameterIuiv
		/// Version: 3.0
		public void TexParameterI(uint target, uint pname, ref uint @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);

			unsafe
			{
				fixed (uint* @paramsPtr = &@params)
				{
					if (this._TexParameterIuiv == null)
						this._TexParameterIuiv = (GLNative.TexParameterIuiv)this.LoadExtensionFunction<GLNative.TexParameterIuiv>();

					this._TexParameterIuiv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameterIuiv);
		}

		/// glTexParameteriv
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexParameteriv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteriv);
		}

		/// glTexParameteriv
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteriv);
		}

		/// glTexParameteriv
		/// Version: 1.0
		public void TexParameter(TextureTarget target, TextureParameterName pname, int[] @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = @params)
				{
					GLNative.TexParameteriv((uint)target, (uint)pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteriv);
		}

		/// glTexParameteriv
		/// Version: 1.0
		public void TexParameter(uint target, uint pname, ref int @params)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexParameteriv);

			unsafe
			{
				fixed (int* @paramsPtr = &@params)
				{
					GLNative.TexParameteriv(target, pname, @paramsPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexParameteriv);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D<T>(TextureTarget target, int level, int xoffset, int width, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage1D((uint)target, level, xoffset, width, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D<T>(uint target, int level, int xoffset, int width, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage1D(target, level, xoffset, width, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D<T>(uint target, int level, int xoffset, int width, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage1D(target, level, xoffset, width, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D(TextureTarget target, int level, int xoffset, int width, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GLNative.TexSubImage1D((uint)target, level, xoffset, width, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D<T>(TextureTarget target, int level, int xoffset, int width, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage1D((uint)target, level, xoffset, width, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage1D
		/// Version: 1.1
		public void TexSubImage1D(uint target, int level, int xoffset, int width, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage1D);

			unsafe
			{
				GLNative.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage1D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GLNative.TexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D<T>(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D<T>(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D<T>(TextureTarget target, int level, int xoffset, int yoffset, int width, int height, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage2D((uint)target, level, xoffset, yoffset, width, height, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D<T>(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					GLNative.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage2D
		/// Version: 1.1
		public void TexSubImage2D(uint target, int level, int xoffset, int yoffset, int width, int height, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage2D);

			unsafe
			{
				GLNative.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage2D);
		}

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D<T>(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, PixelType type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexSubImage3D == null)
						this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

					this._TexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				if (this._TexSubImage3D == null)
					this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

				this._TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D<T>(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, PixelType type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexSubImage3D == null)
						this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

					this._TexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D(TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, PixelFormat format, PixelType type, IntPtr pixels)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				if (this._TexSubImage3D == null)
					this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

				this._TexSubImage3D((uint)target, level, xoffset, yoffset, zoffset, width, height, depth, (uint)format, (uint)type, pixels);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D<T>(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, ref T pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexSubImage3D == null)
						this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

					this._TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		private GLNative.TexSubImage3D _TexSubImage3D;

		/// glTexSubImage3D
		/// Version: 1.2
		public void TexSubImage3D<T>(uint target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, uint format, uint type, T[] pixels) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TexSubImage3D);

			unsafe
			{
				GCHandle pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
				try
				{
					if (this._TexSubImage3D == null)
						this._TexSubImage3D = (GLNative.TexSubImage3D)this.LoadExtensionFunction<GLNative.TexSubImage3D>();

					this._TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (IntPtr)pixelsPtr.AddrOfPinnedObject());
				}
				finally
				{
					pixelsPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TexSubImage3D);
		}

		private GLNative.TransformFeedbackVaryings _TransformFeedbackVaryings;

		/// glTransformFeedbackVaryings
		/// Version: 3.0
		public void TransformFeedbackVaryings(uint program, int count, string[] varyings, uint bufferMode)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.TransformFeedbackVaryings);

			unsafe
			{
				{
					if (this._TransformFeedbackVaryings == null)
						this._TransformFeedbackVaryings = (GLNative.TransformFeedbackVaryings)this.LoadExtensionFunction<GLNative.TransformFeedbackVaryings>();

					this._TransformFeedbackVaryings(program, count, varyings, bufferMode);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.TransformFeedbackVaryings);
		}

		/// glTranslated
		/// Version: 1.0
		public void Translate(double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Translated);

			GLNative.Translated(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Translated);
		}

		/// glTranslatef
		/// Version: 1.0
		public void Translate(float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Translatef);

			GLNative.Translatef(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Translatef);
		}

		private GLNative.Uniform1f _Uniform1f;

		/// glUniform1f
		/// Version: 2.0
		public void Uniform1(int location, float v0)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1f);

			if (this._Uniform1f == null)
				this._Uniform1f = (GLNative.Uniform1f)this.LoadExtensionFunction<GLNative.Uniform1f>();

			this._Uniform1f(location, v0);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1f);
		}

		/// glUniform1fv
		/// Version: 2.0
		public void Uniform1(int location, int count, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._Uniform1fv == null)
						this._Uniform1fv = (GLNative.Uniform1fv)this.LoadExtensionFunction<GLNative.Uniform1fv>();

					this._Uniform1fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1fv);
		}

		private GLNative.Uniform1fv _Uniform1fv;

		/// glUniform1fv
		/// Version: 2.0
		public void Uniform1(int location, int count, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._Uniform1fv == null)
						this._Uniform1fv = (GLNative.Uniform1fv)this.LoadExtensionFunction<GLNative.Uniform1fv>();

					this._Uniform1fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1fv);
		}

		private GLNative.Uniform1i _Uniform1i;

		/// glUniform1i
		/// Version: 2.0
		public void Uniform1(int location, int v0)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1i);

			if (this._Uniform1i == null)
				this._Uniform1i = (GLNative.Uniform1i)this.LoadExtensionFunction<GLNative.Uniform1i>();

			this._Uniform1i(location, v0);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1i);
		}

		/// glUniform1iv
		/// Version: 2.0
		public void Uniform1(int location, int count, ref int value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1iv);

			unsafe
			{
				fixed (int* valuePtr = &value)
				{
					if (this._Uniform1iv == null)
						this._Uniform1iv = (GLNative.Uniform1iv)this.LoadExtensionFunction<GLNative.Uniform1iv>();

					this._Uniform1iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1iv);
		}

		private GLNative.Uniform1iv _Uniform1iv;

		/// glUniform1iv
		/// Version: 2.0
		public void Uniform1(int location, int count, int[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1iv);

			unsafe
			{
				fixed (int* valuePtr = value)
				{
					if (this._Uniform1iv == null)
						this._Uniform1iv = (GLNative.Uniform1iv)this.LoadExtensionFunction<GLNative.Uniform1iv>();

					this._Uniform1iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1iv);
		}

		private GLNative.Uniform1ui _Uniform1ui;

		/// glUniform1ui
		/// Version: 3.0
		public void Uniform1(int location, uint v0)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1ui);

			if (this._Uniform1ui == null)
				this._Uniform1ui = (GLNative.Uniform1ui)this.LoadExtensionFunction<GLNative.Uniform1ui>();

			this._Uniform1ui(location, v0);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1ui);
		}

		/// glUniform1uiv
		/// Version: 3.0
		public void Uniform1(int location, int count, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._Uniform1uiv == null)
						this._Uniform1uiv = (GLNative.Uniform1uiv)this.LoadExtensionFunction<GLNative.Uniform1uiv>();

					this._Uniform1uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1uiv);
		}

		private GLNative.Uniform1uiv _Uniform1uiv;

		/// glUniform1uiv
		/// Version: 3.0
		public void Uniform1(int location, int count, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform1uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._Uniform1uiv == null)
						this._Uniform1uiv = (GLNative.Uniform1uiv)this.LoadExtensionFunction<GLNative.Uniform1uiv>();

					this._Uniform1uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform1uiv);
		}

		private GLNative.Uniform2f _Uniform2f;

		/// glUniform2f
		/// Version: 2.0
		public void Uniform2(int location, float v0, float v1)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2f);

			if (this._Uniform2f == null)
				this._Uniform2f = (GLNative.Uniform2f)this.LoadExtensionFunction<GLNative.Uniform2f>();

			this._Uniform2f(location, v0, v1);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2f);
		}

		/// glUniform2fv
		/// Version: 2.0
		public void Uniform2(int location, int count, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._Uniform2fv == null)
						this._Uniform2fv = (GLNative.Uniform2fv)this.LoadExtensionFunction<GLNative.Uniform2fv>();

					this._Uniform2fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2fv);
		}

		private GLNative.Uniform2fv _Uniform2fv;

		/// glUniform2fv
		/// Version: 2.0
		public void Uniform2(int location, int count, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._Uniform2fv == null)
						this._Uniform2fv = (GLNative.Uniform2fv)this.LoadExtensionFunction<GLNative.Uniform2fv>();

					this._Uniform2fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2fv);
		}

		private GLNative.Uniform2i _Uniform2i;

		/// glUniform2i
		/// Version: 2.0
		public void Uniform2(int location, int v0, int v1)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2i);

			if (this._Uniform2i == null)
				this._Uniform2i = (GLNative.Uniform2i)this.LoadExtensionFunction<GLNative.Uniform2i>();

			this._Uniform2i(location, v0, v1);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2i);
		}

		/// glUniform2iv
		/// Version: 2.0
		public void Uniform2(int location, int count, ref int value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2iv);

			unsafe
			{
				fixed (int* valuePtr = &value)
				{
					if (this._Uniform2iv == null)
						this._Uniform2iv = (GLNative.Uniform2iv)this.LoadExtensionFunction<GLNative.Uniform2iv>();

					this._Uniform2iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2iv);
		}

		private GLNative.Uniform2iv _Uniform2iv;

		/// glUniform2iv
		/// Version: 2.0
		public void Uniform2(int location, int count, int[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2iv);

			unsafe
			{
				fixed (int* valuePtr = value)
				{
					if (this._Uniform2iv == null)
						this._Uniform2iv = (GLNative.Uniform2iv)this.LoadExtensionFunction<GLNative.Uniform2iv>();

					this._Uniform2iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2iv);
		}

		private GLNative.Uniform2ui _Uniform2ui;

		/// glUniform2ui
		/// Version: 3.0
		public void Uniform2(int location, uint v0, uint v1)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2ui);

			if (this._Uniform2ui == null)
				this._Uniform2ui = (GLNative.Uniform2ui)this.LoadExtensionFunction<GLNative.Uniform2ui>();

			this._Uniform2ui(location, v0, v1);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2ui);
		}

		private GLNative.Uniform2uiv _Uniform2uiv;

		/// glUniform2uiv
		/// Version: 3.0
		public void Uniform2(int location, int count, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._Uniform2uiv == null)
						this._Uniform2uiv = (GLNative.Uniform2uiv)this.LoadExtensionFunction<GLNative.Uniform2uiv>();

					this._Uniform2uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2uiv);
		}

		/// glUniform2uiv
		/// Version: 3.0
		public void Uniform2(int location, int count, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform2uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._Uniform2uiv == null)
						this._Uniform2uiv = (GLNative.Uniform2uiv)this.LoadExtensionFunction<GLNative.Uniform2uiv>();

					this._Uniform2uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform2uiv);
		}

		private GLNative.Uniform3f _Uniform3f;

		/// glUniform3f
		/// Version: 2.0
		public void Uniform3(int location, float v0, float v1, float v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3f);

			if (this._Uniform3f == null)
				this._Uniform3f = (GLNative.Uniform3f)this.LoadExtensionFunction<GLNative.Uniform3f>();

			this._Uniform3f(location, v0, v1, v2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3f);
		}

		private GLNative.Uniform3fv _Uniform3fv;

		/// glUniform3fv
		/// Version: 2.0
		public void Uniform3(int location, int count, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._Uniform3fv == null)
						this._Uniform3fv = (GLNative.Uniform3fv)this.LoadExtensionFunction<GLNative.Uniform3fv>();

					this._Uniform3fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3fv);
		}

		/// glUniform3fv
		/// Version: 2.0
		public void Uniform3(int location, int count, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._Uniform3fv == null)
						this._Uniform3fv = (GLNative.Uniform3fv)this.LoadExtensionFunction<GLNative.Uniform3fv>();

					this._Uniform3fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3fv);
		}

		private GLNative.Uniform3i _Uniform3i;

		/// glUniform3i
		/// Version: 2.0
		public void Uniform3(int location, int v0, int v1, int v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3i);

			if (this._Uniform3i == null)
				this._Uniform3i = (GLNative.Uniform3i)this.LoadExtensionFunction<GLNative.Uniform3i>();

			this._Uniform3i(location, v0, v1, v2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3i);
		}

		private GLNative.Uniform3iv _Uniform3iv;

		/// glUniform3iv
		/// Version: 2.0
		public void Uniform3(int location, int count, int[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3iv);

			unsafe
			{
				fixed (int* valuePtr = value)
				{
					if (this._Uniform3iv == null)
						this._Uniform3iv = (GLNative.Uniform3iv)this.LoadExtensionFunction<GLNative.Uniform3iv>();

					this._Uniform3iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3iv);
		}

		/// glUniform3iv
		/// Version: 2.0
		public void Uniform3(int location, int count, ref int value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3iv);

			unsafe
			{
				fixed (int* valuePtr = &value)
				{
					if (this._Uniform3iv == null)
						this._Uniform3iv = (GLNative.Uniform3iv)this.LoadExtensionFunction<GLNative.Uniform3iv>();

					this._Uniform3iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3iv);
		}

		private GLNative.Uniform3ui _Uniform3ui;

		/// glUniform3ui
		/// Version: 3.0
		public void Uniform3(int location, uint v0, uint v1, uint v2)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3ui);

			if (this._Uniform3ui == null)
				this._Uniform3ui = (GLNative.Uniform3ui)this.LoadExtensionFunction<GLNative.Uniform3ui>();

			this._Uniform3ui(location, v0, v1, v2);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3ui);
		}

		/// glUniform3uiv
		/// Version: 3.0
		public void Uniform3(int location, int count, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._Uniform3uiv == null)
						this._Uniform3uiv = (GLNative.Uniform3uiv)this.LoadExtensionFunction<GLNative.Uniform3uiv>();

					this._Uniform3uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3uiv);
		}

		private GLNative.Uniform3uiv _Uniform3uiv;

		/// glUniform3uiv
		/// Version: 3.0
		public void Uniform3(int location, int count, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform3uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._Uniform3uiv == null)
						this._Uniform3uiv = (GLNative.Uniform3uiv)this.LoadExtensionFunction<GLNative.Uniform3uiv>();

					this._Uniform3uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform3uiv);
		}

		private GLNative.Uniform4f _Uniform4f;

		/// glUniform4f
		/// Version: 2.0
		public void Uniform4(int location, float v0, float v1, float v2, float v3)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4f);

			if (this._Uniform4f == null)
				this._Uniform4f = (GLNative.Uniform4f)this.LoadExtensionFunction<GLNative.Uniform4f>();

			this._Uniform4f(location, v0, v1, v2, v3);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4f);
		}

		private GLNative.Uniform4fv _Uniform4fv;

		/// glUniform4fv
		/// Version: 2.0
		public void Uniform4(int location, int count, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._Uniform4fv == null)
						this._Uniform4fv = (GLNative.Uniform4fv)this.LoadExtensionFunction<GLNative.Uniform4fv>();

					this._Uniform4fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4fv);
		}

		/// glUniform4fv
		/// Version: 2.0
		public void Uniform4(int location, int count, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._Uniform4fv == null)
						this._Uniform4fv = (GLNative.Uniform4fv)this.LoadExtensionFunction<GLNative.Uniform4fv>();

					this._Uniform4fv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4fv);
		}

		private GLNative.Uniform4i _Uniform4i;

		/// glUniform4i
		/// Version: 2.0
		public void Uniform4(int location, int v0, int v1, int v2, int v3)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4i);

			if (this._Uniform4i == null)
				this._Uniform4i = (GLNative.Uniform4i)this.LoadExtensionFunction<GLNative.Uniform4i>();

			this._Uniform4i(location, v0, v1, v2, v3);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4i);
		}

		private GLNative.Uniform4iv _Uniform4iv;

		/// glUniform4iv
		/// Version: 2.0
		public void Uniform4(int location, int count, int[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4iv);

			unsafe
			{
				fixed (int* valuePtr = value)
				{
					if (this._Uniform4iv == null)
						this._Uniform4iv = (GLNative.Uniform4iv)this.LoadExtensionFunction<GLNative.Uniform4iv>();

					this._Uniform4iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4iv);
		}

		/// glUniform4iv
		/// Version: 2.0
		public void Uniform4(int location, int count, ref int value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4iv);

			unsafe
			{
				fixed (int* valuePtr = &value)
				{
					if (this._Uniform4iv == null)
						this._Uniform4iv = (GLNative.Uniform4iv)this.LoadExtensionFunction<GLNative.Uniform4iv>();

					this._Uniform4iv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4iv);
		}

		private GLNative.Uniform4ui _Uniform4ui;

		/// glUniform4ui
		/// Version: 3.0
		public void Uniform4(int location, uint v0, uint v1, uint v2, uint v3)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4ui);

			if (this._Uniform4ui == null)
				this._Uniform4ui = (GLNative.Uniform4ui)this.LoadExtensionFunction<GLNative.Uniform4ui>();

			this._Uniform4ui(location, v0, v1, v2, v3);

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4ui);
		}

		private GLNative.Uniform4uiv _Uniform4uiv;

		/// glUniform4uiv
		/// Version: 3.0
		public void Uniform4(int location, int count, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._Uniform4uiv == null)
						this._Uniform4uiv = (GLNative.Uniform4uiv)this.LoadExtensionFunction<GLNative.Uniform4uiv>();

					this._Uniform4uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4uiv);
		}

		/// glUniform4uiv
		/// Version: 3.0
		public void Uniform4(int location, int count, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Uniform4uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._Uniform4uiv == null)
						this._Uniform4uiv = (GLNative.Uniform4uiv)this.LoadExtensionFunction<GLNative.Uniform4uiv>();

					this._Uniform4uiv(location, count, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Uniform4uiv);
		}

		private GLNative.UniformBlockBinding _UniformBlockBinding;

		/// glUniformBlockBinding
		/// Version: 3.1
		public void UniformBlockBinding(uint program, uint uniformBlockIndex, uint uniformBlockBinding)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformBlockBinding);

			if (this._UniformBlockBinding == null)
				this._UniformBlockBinding = (GLNative.UniformBlockBinding)this.LoadExtensionFunction<GLNative.UniformBlockBinding>();

			this._UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformBlockBinding);
		}

		/// glUniformMatrix2fv
		/// Version: 2.0
		public void UniformMatrix2(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix2fv == null)
						this._UniformMatrix2fv = (GLNative.UniformMatrix2fv)this.LoadExtensionFunction<GLNative.UniformMatrix2fv>();

					this._UniformMatrix2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2fv);
		}

		private GLNative.UniformMatrix2fv _UniformMatrix2fv;

		/// glUniformMatrix2fv
		/// Version: 2.0
		public void UniformMatrix2(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix2fv == null)
						this._UniformMatrix2fv = (GLNative.UniformMatrix2fv)this.LoadExtensionFunction<GLNative.UniformMatrix2fv>();

					this._UniformMatrix2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2fv);
		}

		private GLNative.UniformMatrix2x3fv _UniformMatrix2x3fv;

		/// glUniformMatrix2x3fv
		/// Version: 2.1
		public void UniformMatrix2x3(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2x3fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix2x3fv == null)
						this._UniformMatrix2x3fv = (GLNative.UniformMatrix2x3fv)this.LoadExtensionFunction<GLNative.UniformMatrix2x3fv>();

					this._UniformMatrix2x3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2x3fv);
		}

		/// glUniformMatrix2x3fv
		/// Version: 2.1
		public void UniformMatrix2x3(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2x3fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix2x3fv == null)
						this._UniformMatrix2x3fv = (GLNative.UniformMatrix2x3fv)this.LoadExtensionFunction<GLNative.UniformMatrix2x3fv>();

					this._UniformMatrix2x3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2x3fv);
		}

		private GLNative.UniformMatrix2x4fv _UniformMatrix2x4fv;

		/// glUniformMatrix2x4fv
		/// Version: 2.1
		public void UniformMatrix2x4(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2x4fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix2x4fv == null)
						this._UniformMatrix2x4fv = (GLNative.UniformMatrix2x4fv)this.LoadExtensionFunction<GLNative.UniformMatrix2x4fv>();

					this._UniformMatrix2x4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2x4fv);
		}

		/// glUniformMatrix2x4fv
		/// Version: 2.1
		public void UniformMatrix2x4(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix2x4fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix2x4fv == null)
						this._UniformMatrix2x4fv = (GLNative.UniformMatrix2x4fv)this.LoadExtensionFunction<GLNative.UniformMatrix2x4fv>();

					this._UniformMatrix2x4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix2x4fv);
		}

		/// glUniformMatrix3fv
		/// Version: 2.0
		public void UniformMatrix3(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix3fv == null)
						this._UniformMatrix3fv = (GLNative.UniformMatrix3fv)this.LoadExtensionFunction<GLNative.UniformMatrix3fv>();

					this._UniformMatrix3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3fv);
		}

		private GLNative.UniformMatrix3fv _UniformMatrix3fv;

		/// glUniformMatrix3fv
		/// Version: 2.0
		public void UniformMatrix3(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix3fv == null)
						this._UniformMatrix3fv = (GLNative.UniformMatrix3fv)this.LoadExtensionFunction<GLNative.UniformMatrix3fv>();

					this._UniformMatrix3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3fv);
		}

		private GLNative.UniformMatrix3x2fv _UniformMatrix3x2fv;

		/// glUniformMatrix3x2fv
		/// Version: 2.1
		public void UniformMatrix3x2(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3x2fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix3x2fv == null)
						this._UniformMatrix3x2fv = (GLNative.UniformMatrix3x2fv)this.LoadExtensionFunction<GLNative.UniformMatrix3x2fv>();

					this._UniformMatrix3x2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3x2fv);
		}

		/// glUniformMatrix3x2fv
		/// Version: 2.1
		public void UniformMatrix3x2(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3x2fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix3x2fv == null)
						this._UniformMatrix3x2fv = (GLNative.UniformMatrix3x2fv)this.LoadExtensionFunction<GLNative.UniformMatrix3x2fv>();

					this._UniformMatrix3x2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3x2fv);
		}

		private GLNative.UniformMatrix3x4fv _UniformMatrix3x4fv;

		/// glUniformMatrix3x4fv
		/// Version: 2.1
		public void UniformMatrix3x4(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3x4fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix3x4fv == null)
						this._UniformMatrix3x4fv = (GLNative.UniformMatrix3x4fv)this.LoadExtensionFunction<GLNative.UniformMatrix3x4fv>();

					this._UniformMatrix3x4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3x4fv);
		}

		/// glUniformMatrix3x4fv
		/// Version: 2.1
		public void UniformMatrix3x4(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix3x4fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix3x4fv == null)
						this._UniformMatrix3x4fv = (GLNative.UniformMatrix3x4fv)this.LoadExtensionFunction<GLNative.UniformMatrix3x4fv>();

					this._UniformMatrix3x4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix3x4fv);
		}

		/// glUniformMatrix4fv
		/// Version: 2.0
		public void UniformMatrix4(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix4fv == null)
						this._UniformMatrix4fv = (GLNative.UniformMatrix4fv)this.LoadExtensionFunction<GLNative.UniformMatrix4fv>();

					this._UniformMatrix4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4fv);
		}

		private GLNative.UniformMatrix4fv _UniformMatrix4fv;

		/// glUniformMatrix4fv
		/// Version: 2.0
		public void UniformMatrix4(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix4fv == null)
						this._UniformMatrix4fv = (GLNative.UniformMatrix4fv)this.LoadExtensionFunction<GLNative.UniformMatrix4fv>();

					this._UniformMatrix4fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4fv);
		}

		/// glUniformMatrix4x2fv
		/// Version: 2.1
		public void UniformMatrix4x2(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4x2fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix4x2fv == null)
						this._UniformMatrix4x2fv = (GLNative.UniformMatrix4x2fv)this.LoadExtensionFunction<GLNative.UniformMatrix4x2fv>();

					this._UniformMatrix4x2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4x2fv);
		}

		private GLNative.UniformMatrix4x2fv _UniformMatrix4x2fv;

		/// glUniformMatrix4x2fv
		/// Version: 2.1
		public void UniformMatrix4x2(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4x2fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix4x2fv == null)
						this._UniformMatrix4x2fv = (GLNative.UniformMatrix4x2fv)this.LoadExtensionFunction<GLNative.UniformMatrix4x2fv>();

					this._UniformMatrix4x2fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4x2fv);
		}

		/// glUniformMatrix4x3fv
		/// Version: 2.1
		public void UniformMatrix4x3(int location, int count, bool transpose, ref float value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4x3fv);

			unsafe
			{
				fixed (float* valuePtr = &value)
				{
					if (this._UniformMatrix4x3fv == null)
						this._UniformMatrix4x3fv = (GLNative.UniformMatrix4x3fv)this.LoadExtensionFunction<GLNative.UniformMatrix4x3fv>();

					this._UniformMatrix4x3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4x3fv);
		}

		private GLNative.UniformMatrix4x3fv _UniformMatrix4x3fv;

		/// glUniformMatrix4x3fv
		/// Version: 2.1
		public void UniformMatrix4x3(int location, int count, bool transpose, float[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UniformMatrix4x3fv);

			unsafe
			{
				fixed (float* valuePtr = value)
				{
					if (this._UniformMatrix4x3fv == null)
						this._UniformMatrix4x3fv = (GLNative.UniformMatrix4x3fv)this.LoadExtensionFunction<GLNative.UniformMatrix4x3fv>();

					this._UniformMatrix4x3fv(location, count, transpose, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.UniformMatrix4x3fv);
		}

		private GLNative.UnmapBuffer _UnmapBuffer;

		/// glUnmapBuffer
		/// Version: 1.5
		public bool UnmapBuffer(uint target)
		{
			bool result;

			this.BeforeNativeFunctionCall(GLNativeFunctions.UnmapBuffer);

			if (this._UnmapBuffer == null)
				this._UnmapBuffer = (GLNative.UnmapBuffer)this.LoadExtensionFunction<GLNative.UnmapBuffer>();

			result = this._UnmapBuffer(target);

			this.AfterNativeFunctionCall(GLNativeFunctions.UnmapBuffer);

			return result;
		}

		private GLNative.UseProgram _UseProgram;

		/// glUseProgram
		/// Version: 2.0
		public void UseProgram(uint program)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.UseProgram);

			if (this._UseProgram == null)
				this._UseProgram = (GLNative.UseProgram)this.LoadExtensionFunction<GLNative.UseProgram>();

			this._UseProgram(program);

			this.AfterNativeFunctionCall(GLNativeFunctions.UseProgram);
		}

		private GLNative.ValidateProgram _ValidateProgram;

		/// glValidateProgram
		/// Version: 2.0
		public void ValidateProgram(uint program)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.ValidateProgram);

			if (this._ValidateProgram == null)
				this._ValidateProgram = (GLNative.ValidateProgram)this.LoadExtensionFunction<GLNative.ValidateProgram>();

			this._ValidateProgram(program);

			this.AfterNativeFunctionCall(GLNativeFunctions.ValidateProgram);
		}

		/// glVertex2d
		/// Version: 1.0
		public void Vertex2(double x, double y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2d);

			GLNative.Vertex2d(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2d);
		}

		/// glVertex2dv
		/// Version: 1.0
		public void Vertex2(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Vertex2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2dv);
		}

		/// glVertex2dv
		/// Version: 1.0
		public void Vertex2(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Vertex2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2dv);
		}

		/// glVertex2f
		/// Version: 1.0
		public void Vertex2(float x, float y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2f);

			GLNative.Vertex2f(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2f);
		}

		/// glVertex2fv
		/// Version: 1.0
		public void Vertex2(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Vertex2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2fv);
		}

		/// glVertex2fv
		/// Version: 1.0
		public void Vertex2(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Vertex2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2fv);
		}

		/// glVertex2i
		/// Version: 1.0
		public void Vertex2(int x, int y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2i);

			GLNative.Vertex2i(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2i);
		}

		/// glVertex2iv
		/// Version: 1.0
		public void Vertex2(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Vertex2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2iv);
		}

		/// glVertex2iv
		/// Version: 1.0
		public void Vertex2(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Vertex2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2iv);
		}

		/// glVertex2s
		/// Version: 1.0
		public void Vertex2(short x, short y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2s);

			GLNative.Vertex2s(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2s);
		}

		/// glVertex2sv
		/// Version: 1.0
		public void Vertex2(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Vertex2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2sv);
		}

		/// glVertex2sv
		/// Version: 1.0
		public void Vertex2(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Vertex2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex2sv);
		}

		/// glVertex3d
		/// Version: 1.0
		public void Vertex3(double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3d);

			GLNative.Vertex3d(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3d);
		}

		/// glVertex3dv
		/// Version: 1.0
		public void Vertex3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Vertex3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3dv);
		}

		/// glVertex3dv
		/// Version: 1.0
		public void Vertex3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Vertex3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3dv);
		}

		/// glVertex3f
		/// Version: 1.0
		public void Vertex3(float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3f);

			GLNative.Vertex3f(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3f);
		}

		/// glVertex3fv
		/// Version: 1.0
		public void Vertex3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Vertex3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3fv);
		}

		/// glVertex3fv
		/// Version: 1.0
		public void Vertex3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Vertex3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3fv);
		}

		/// glVertex3i
		/// Version: 1.0
		public void Vertex3(int x, int y, int z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3i);

			GLNative.Vertex3i(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3i);
		}

		/// glVertex3iv
		/// Version: 1.0
		public void Vertex3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Vertex3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3iv);
		}

		/// glVertex3iv
		/// Version: 1.0
		public void Vertex3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Vertex3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3iv);
		}

		/// glVertex3s
		/// Version: 1.0
		public void Vertex3(short x, short y, short z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3s);

			GLNative.Vertex3s(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3s);
		}

		/// glVertex3sv
		/// Version: 1.0
		public void Vertex3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Vertex3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3sv);
		}

		/// glVertex3sv
		/// Version: 1.0
		public void Vertex3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Vertex3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex3sv);
		}

		/// glVertex4d
		/// Version: 1.0
		public void Vertex4(double x, double y, double z, double w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4d);

			GLNative.Vertex4d(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4d);
		}

		/// glVertex4dv
		/// Version: 1.0
		public void Vertex4(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					GLNative.Vertex4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4dv);
		}

		/// glVertex4dv
		/// Version: 1.0
		public void Vertex4(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					GLNative.Vertex4dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4dv);
		}

		/// glVertex4f
		/// Version: 1.0
		public void Vertex4(float x, float y, float z, float w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4f);

			GLNative.Vertex4f(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4f);
		}

		/// glVertex4fv
		/// Version: 1.0
		public void Vertex4(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					GLNative.Vertex4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4fv);
		}

		/// glVertex4fv
		/// Version: 1.0
		public void Vertex4(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					GLNative.Vertex4fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4fv);
		}

		/// glVertex4i
		/// Version: 1.0
		public void Vertex4(int x, int y, int z, int w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4i);

			GLNative.Vertex4i(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4i);
		}

		/// glVertex4iv
		/// Version: 1.0
		public void Vertex4(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					GLNative.Vertex4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4iv);
		}

		/// glVertex4iv
		/// Version: 1.0
		public void Vertex4(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					GLNative.Vertex4iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4iv);
		}

		/// glVertex4s
		/// Version: 1.0
		public void Vertex4(short x, short y, short z, short w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4s);

			GLNative.Vertex4s(x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4s);
		}

		/// glVertex4sv
		/// Version: 1.0
		public void Vertex4(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					GLNative.Vertex4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4sv);
		}

		/// glVertex4sv
		/// Version: 1.0
		public void Vertex4(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Vertex4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					GLNative.Vertex4sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.Vertex4sv);
		}

		private GLNative.VertexAttrib1d _VertexAttrib1d;

		/// glVertexAttrib1d
		/// Version: 2.0
		public void VertexAttrib1(uint index, double x)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1d);

			if (this._VertexAttrib1d == null)
				this._VertexAttrib1d = (GLNative.VertexAttrib1d)this.LoadExtensionFunction<GLNative.VertexAttrib1d>();

			this._VertexAttrib1d(index, x);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1d);
		}

		/// glVertexAttrib1dv
		/// Version: 2.0
		public void VertexAttrib1(uint index, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._VertexAttrib1dv == null)
						this._VertexAttrib1dv = (GLNative.VertexAttrib1dv)this.LoadExtensionFunction<GLNative.VertexAttrib1dv>();

					this._VertexAttrib1dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1dv);
		}

		private GLNative.VertexAttrib1dv _VertexAttrib1dv;

		/// glVertexAttrib1dv
		/// Version: 2.0
		public void VertexAttrib1(uint index, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._VertexAttrib1dv == null)
						this._VertexAttrib1dv = (GLNative.VertexAttrib1dv)this.LoadExtensionFunction<GLNative.VertexAttrib1dv>();

					this._VertexAttrib1dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1dv);
		}

		private GLNative.VertexAttrib1f _VertexAttrib1f;

		/// glVertexAttrib1f
		/// Version: 2.0
		public void VertexAttrib1(uint index, float x)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1f);

			if (this._VertexAttrib1f == null)
				this._VertexAttrib1f = (GLNative.VertexAttrib1f)this.LoadExtensionFunction<GLNative.VertexAttrib1f>();

			this._VertexAttrib1f(index, x);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1f);
		}

		private GLNative.VertexAttrib1fv _VertexAttrib1fv;

		/// glVertexAttrib1fv
		/// Version: 2.0
		public void VertexAttrib1(uint index, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._VertexAttrib1fv == null)
						this._VertexAttrib1fv = (GLNative.VertexAttrib1fv)this.LoadExtensionFunction<GLNative.VertexAttrib1fv>();

					this._VertexAttrib1fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1fv);
		}

		/// glVertexAttrib1fv
		/// Version: 2.0
		public void VertexAttrib1(uint index, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._VertexAttrib1fv == null)
						this._VertexAttrib1fv = (GLNative.VertexAttrib1fv)this.LoadExtensionFunction<GLNative.VertexAttrib1fv>();

					this._VertexAttrib1fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1fv);
		}

		private GLNative.VertexAttrib1s _VertexAttrib1s;

		/// glVertexAttrib1s
		/// Version: 2.0
		public void VertexAttrib1(uint index, short x)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1s);

			if (this._VertexAttrib1s == null)
				this._VertexAttrib1s = (GLNative.VertexAttrib1s)this.LoadExtensionFunction<GLNative.VertexAttrib1s>();

			this._VertexAttrib1s(index, x);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1s);
		}

		private GLNative.VertexAttrib1sv _VertexAttrib1sv;

		/// glVertexAttrib1sv
		/// Version: 2.0
		public void VertexAttrib1(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttrib1sv == null)
						this._VertexAttrib1sv = (GLNative.VertexAttrib1sv)this.LoadExtensionFunction<GLNative.VertexAttrib1sv>();

					this._VertexAttrib1sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1sv);
		}

		/// glVertexAttrib1sv
		/// Version: 2.0
		public void VertexAttrib1(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib1sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttrib1sv == null)
						this._VertexAttrib1sv = (GLNative.VertexAttrib1sv)this.LoadExtensionFunction<GLNative.VertexAttrib1sv>();

					this._VertexAttrib1sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib1sv);
		}

		private GLNative.VertexAttrib2d _VertexAttrib2d;

		/// glVertexAttrib2d
		/// Version: 2.0
		public void VertexAttrib2(uint index, double x, double y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2d);

			if (this._VertexAttrib2d == null)
				this._VertexAttrib2d = (GLNative.VertexAttrib2d)this.LoadExtensionFunction<GLNative.VertexAttrib2d>();

			this._VertexAttrib2d(index, x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2d);
		}

		private GLNative.VertexAttrib2dv _VertexAttrib2dv;

		/// glVertexAttrib2dv
		/// Version: 2.0
		public void VertexAttrib2(uint index, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._VertexAttrib2dv == null)
						this._VertexAttrib2dv = (GLNative.VertexAttrib2dv)this.LoadExtensionFunction<GLNative.VertexAttrib2dv>();

					this._VertexAttrib2dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2dv);
		}

		/// glVertexAttrib2dv
		/// Version: 2.0
		public void VertexAttrib2(uint index, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._VertexAttrib2dv == null)
						this._VertexAttrib2dv = (GLNative.VertexAttrib2dv)this.LoadExtensionFunction<GLNative.VertexAttrib2dv>();

					this._VertexAttrib2dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2dv);
		}

		private GLNative.VertexAttrib2f _VertexAttrib2f;

		/// glVertexAttrib2f
		/// Version: 2.0
		public void VertexAttrib2(uint index, float x, float y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2f);

			if (this._VertexAttrib2f == null)
				this._VertexAttrib2f = (GLNative.VertexAttrib2f)this.LoadExtensionFunction<GLNative.VertexAttrib2f>();

			this._VertexAttrib2f(index, x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2f);
		}

		/// glVertexAttrib2fv
		/// Version: 2.0
		public void VertexAttrib2(uint index, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._VertexAttrib2fv == null)
						this._VertexAttrib2fv = (GLNative.VertexAttrib2fv)this.LoadExtensionFunction<GLNative.VertexAttrib2fv>();

					this._VertexAttrib2fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2fv);
		}

		private GLNative.VertexAttrib2fv _VertexAttrib2fv;

		/// glVertexAttrib2fv
		/// Version: 2.0
		public void VertexAttrib2(uint index, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._VertexAttrib2fv == null)
						this._VertexAttrib2fv = (GLNative.VertexAttrib2fv)this.LoadExtensionFunction<GLNative.VertexAttrib2fv>();

					this._VertexAttrib2fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2fv);
		}

		private GLNative.VertexAttrib2s _VertexAttrib2s;

		/// glVertexAttrib2s
		/// Version: 2.0
		public void VertexAttrib2(uint index, short x, short y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2s);

			if (this._VertexAttrib2s == null)
				this._VertexAttrib2s = (GLNative.VertexAttrib2s)this.LoadExtensionFunction<GLNative.VertexAttrib2s>();

			this._VertexAttrib2s(index, x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2s);
		}

		private GLNative.VertexAttrib2sv _VertexAttrib2sv;

		/// glVertexAttrib2sv
		/// Version: 2.0
		public void VertexAttrib2(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttrib2sv == null)
						this._VertexAttrib2sv = (GLNative.VertexAttrib2sv)this.LoadExtensionFunction<GLNative.VertexAttrib2sv>();

					this._VertexAttrib2sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2sv);
		}

		/// glVertexAttrib2sv
		/// Version: 2.0
		public void VertexAttrib2(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttrib2sv == null)
						this._VertexAttrib2sv = (GLNative.VertexAttrib2sv)this.LoadExtensionFunction<GLNative.VertexAttrib2sv>();

					this._VertexAttrib2sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib2sv);
		}

		private GLNative.VertexAttrib3d _VertexAttrib3d;

		/// glVertexAttrib3d
		/// Version: 2.0
		public void VertexAttrib3(uint index, double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3d);

			if (this._VertexAttrib3d == null)
				this._VertexAttrib3d = (GLNative.VertexAttrib3d)this.LoadExtensionFunction<GLNative.VertexAttrib3d>();

			this._VertexAttrib3d(index, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3d);
		}

		private GLNative.VertexAttrib3dv _VertexAttrib3dv;

		/// glVertexAttrib3dv
		/// Version: 2.0
		public void VertexAttrib3(uint index, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._VertexAttrib3dv == null)
						this._VertexAttrib3dv = (GLNative.VertexAttrib3dv)this.LoadExtensionFunction<GLNative.VertexAttrib3dv>();

					this._VertexAttrib3dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3dv);
		}

		/// glVertexAttrib3dv
		/// Version: 2.0
		public void VertexAttrib3(uint index, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._VertexAttrib3dv == null)
						this._VertexAttrib3dv = (GLNative.VertexAttrib3dv)this.LoadExtensionFunction<GLNative.VertexAttrib3dv>();

					this._VertexAttrib3dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3dv);
		}

		private GLNative.VertexAttrib3f _VertexAttrib3f;

		/// glVertexAttrib3f
		/// Version: 2.0
		public void VertexAttrib3(uint index, float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3f);

			if (this._VertexAttrib3f == null)
				this._VertexAttrib3f = (GLNative.VertexAttrib3f)this.LoadExtensionFunction<GLNative.VertexAttrib3f>();

			this._VertexAttrib3f(index, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3f);
		}

		/// glVertexAttrib3fv
		/// Version: 2.0
		public void VertexAttrib3(uint index, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._VertexAttrib3fv == null)
						this._VertexAttrib3fv = (GLNative.VertexAttrib3fv)this.LoadExtensionFunction<GLNative.VertexAttrib3fv>();

					this._VertexAttrib3fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3fv);
		}

		private GLNative.VertexAttrib3fv _VertexAttrib3fv;

		/// glVertexAttrib3fv
		/// Version: 2.0
		public void VertexAttrib3(uint index, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._VertexAttrib3fv == null)
						this._VertexAttrib3fv = (GLNative.VertexAttrib3fv)this.LoadExtensionFunction<GLNative.VertexAttrib3fv>();

					this._VertexAttrib3fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3fv);
		}

		private GLNative.VertexAttrib3s _VertexAttrib3s;

		/// glVertexAttrib3s
		/// Version: 2.0
		public void VertexAttrib3(uint index, short x, short y, short z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3s);

			if (this._VertexAttrib3s == null)
				this._VertexAttrib3s = (GLNative.VertexAttrib3s)this.LoadExtensionFunction<GLNative.VertexAttrib3s>();

			this._VertexAttrib3s(index, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3s);
		}

		private GLNative.VertexAttrib3sv _VertexAttrib3sv;

		/// glVertexAttrib3sv
		/// Version: 2.0
		public void VertexAttrib3(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttrib3sv == null)
						this._VertexAttrib3sv = (GLNative.VertexAttrib3sv)this.LoadExtensionFunction<GLNative.VertexAttrib3sv>();

					this._VertexAttrib3sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3sv);
		}

		/// glVertexAttrib3sv
		/// Version: 2.0
		public void VertexAttrib3(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttrib3sv == null)
						this._VertexAttrib3sv = (GLNative.VertexAttrib3sv)this.LoadExtensionFunction<GLNative.VertexAttrib3sv>();

					this._VertexAttrib3sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib3sv);
		}

		private GLNative.VertexAttrib4bv _VertexAttrib4bv;

		/// glVertexAttrib4bv
		/// Version: 2.0
		public void VertexAttrib4(uint index, sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					if (this._VertexAttrib4bv == null)
						this._VertexAttrib4bv = (GLNative.VertexAttrib4bv)this.LoadExtensionFunction<GLNative.VertexAttrib4bv>();

					this._VertexAttrib4bv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4bv);
		}

		/// glVertexAttrib4bv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					if (this._VertexAttrib4bv == null)
						this._VertexAttrib4bv = (GLNative.VertexAttrib4bv)this.LoadExtensionFunction<GLNative.VertexAttrib4bv>();

					this._VertexAttrib4bv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4bv);
		}

		private GLNative.VertexAttrib4d _VertexAttrib4d;

		/// glVertexAttrib4d
		/// Version: 2.0
		public void VertexAttrib4(uint index, double x, double y, double z, double w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4d);

			if (this._VertexAttrib4d == null)
				this._VertexAttrib4d = (GLNative.VertexAttrib4d)this.LoadExtensionFunction<GLNative.VertexAttrib4d>();

			this._VertexAttrib4d(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4d);
		}

		/// glVertexAttrib4dv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._VertexAttrib4dv == null)
						this._VertexAttrib4dv = (GLNative.VertexAttrib4dv)this.LoadExtensionFunction<GLNative.VertexAttrib4dv>();

					this._VertexAttrib4dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4dv);
		}

		private GLNative.VertexAttrib4dv _VertexAttrib4dv;

		/// glVertexAttrib4dv
		/// Version: 2.0
		public void VertexAttrib4(uint index, double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._VertexAttrib4dv == null)
						this._VertexAttrib4dv = (GLNative.VertexAttrib4dv)this.LoadExtensionFunction<GLNative.VertexAttrib4dv>();

					this._VertexAttrib4dv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4dv);
		}

		private GLNative.VertexAttrib4f _VertexAttrib4f;

		/// glVertexAttrib4f
		/// Version: 2.0
		public void VertexAttrib4(uint index, float x, float y, float z, float w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4f);

			if (this._VertexAttrib4f == null)
				this._VertexAttrib4f = (GLNative.VertexAttrib4f)this.LoadExtensionFunction<GLNative.VertexAttrib4f>();

			this._VertexAttrib4f(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4f);
		}

		private GLNative.VertexAttrib4fv _VertexAttrib4fv;

		/// glVertexAttrib4fv
		/// Version: 2.0
		public void VertexAttrib4(uint index, float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._VertexAttrib4fv == null)
						this._VertexAttrib4fv = (GLNative.VertexAttrib4fv)this.LoadExtensionFunction<GLNative.VertexAttrib4fv>();

					this._VertexAttrib4fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4fv);
		}

		/// glVertexAttrib4fv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._VertexAttrib4fv == null)
						this._VertexAttrib4fv = (GLNative.VertexAttrib4fv)this.LoadExtensionFunction<GLNative.VertexAttrib4fv>();

					this._VertexAttrib4fv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4fv);
		}

		private GLNative.VertexAttrib4iv _VertexAttrib4iv;

		/// glVertexAttrib4iv
		/// Version: 2.0
		public void VertexAttrib4(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttrib4iv == null)
						this._VertexAttrib4iv = (GLNative.VertexAttrib4iv)this.LoadExtensionFunction<GLNative.VertexAttrib4iv>();

					this._VertexAttrib4iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4iv);
		}

		/// glVertexAttrib4iv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttrib4iv == null)
						this._VertexAttrib4iv = (GLNative.VertexAttrib4iv)this.LoadExtensionFunction<GLNative.VertexAttrib4iv>();

					this._VertexAttrib4iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4iv);
		}

		private GLNative.VertexAttrib4Nbv _VertexAttrib4Nbv;

		/// glVertexAttrib4Nbv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nbv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					if (this._VertexAttrib4Nbv == null)
						this._VertexAttrib4Nbv = (GLNative.VertexAttrib4Nbv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nbv>();

					this._VertexAttrib4Nbv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nbv);
		}

		/// glVertexAttrib4Nbv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nbv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					if (this._VertexAttrib4Nbv == null)
						this._VertexAttrib4Nbv = (GLNative.VertexAttrib4Nbv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nbv>();

					this._VertexAttrib4Nbv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nbv);
		}

		/// glVertexAttrib4Niv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Niv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttrib4Niv == null)
						this._VertexAttrib4Niv = (GLNative.VertexAttrib4Niv)this.LoadExtensionFunction<GLNative.VertexAttrib4Niv>();

					this._VertexAttrib4Niv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Niv);
		}

		private GLNative.VertexAttrib4Niv _VertexAttrib4Niv;

		/// glVertexAttrib4Niv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Niv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttrib4Niv == null)
						this._VertexAttrib4Niv = (GLNative.VertexAttrib4Niv)this.LoadExtensionFunction<GLNative.VertexAttrib4Niv>();

					this._VertexAttrib4Niv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Niv);
		}

		/// glVertexAttrib4Nsv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nsv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttrib4Nsv == null)
						this._VertexAttrib4Nsv = (GLNative.VertexAttrib4Nsv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nsv>();

					this._VertexAttrib4Nsv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nsv);
		}

		private GLNative.VertexAttrib4Nsv _VertexAttrib4Nsv;

		/// glVertexAttrib4Nsv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nsv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttrib4Nsv == null)
						this._VertexAttrib4Nsv = (GLNative.VertexAttrib4Nsv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nsv>();

					this._VertexAttrib4Nsv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nsv);
		}

		private GLNative.VertexAttrib4Nub _VertexAttrib4Nub;

		/// glVertexAttrib4Nub
		/// Version: 2.0
		public void VertexAttrib4Nu(uint index, byte x, byte y, byte z, byte w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nub);

			if (this._VertexAttrib4Nub == null)
				this._VertexAttrib4Nub = (GLNative.VertexAttrib4Nub)this.LoadExtensionFunction<GLNative.VertexAttrib4Nub>();

			this._VertexAttrib4Nub(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nub);
		}

		/// glVertexAttrib4Nubv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					if (this._VertexAttrib4Nubv == null)
						this._VertexAttrib4Nubv = (GLNative.VertexAttrib4Nubv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nubv>();

					this._VertexAttrib4Nubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nubv);
		}

		private GLNative.VertexAttrib4Nubv _VertexAttrib4Nubv;

		/// glVertexAttrib4Nubv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					if (this._VertexAttrib4Nubv == null)
						this._VertexAttrib4Nubv = (GLNative.VertexAttrib4Nubv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nubv>();

					this._VertexAttrib4Nubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nubv);
		}

		/// glVertexAttrib4Nuiv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nuiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttrib4Nuiv == null)
						this._VertexAttrib4Nuiv = (GLNative.VertexAttrib4Nuiv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nuiv>();

					this._VertexAttrib4Nuiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nuiv);
		}

		private GLNative.VertexAttrib4Nuiv _VertexAttrib4Nuiv;

		/// glVertexAttrib4Nuiv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nuiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttrib4Nuiv == null)
						this._VertexAttrib4Nuiv = (GLNative.VertexAttrib4Nuiv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nuiv>();

					this._VertexAttrib4Nuiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nuiv);
		}

		/// glVertexAttrib4Nusv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nusv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					if (this._VertexAttrib4Nusv == null)
						this._VertexAttrib4Nusv = (GLNative.VertexAttrib4Nusv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nusv>();

					this._VertexAttrib4Nusv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nusv);
		}

		private GLNative.VertexAttrib4Nusv _VertexAttrib4Nusv;

		/// glVertexAttrib4Nusv
		/// Version: 2.0
		public void VertexAttrib4N(uint index, ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nusv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					if (this._VertexAttrib4Nusv == null)
						this._VertexAttrib4Nusv = (GLNative.VertexAttrib4Nusv)this.LoadExtensionFunction<GLNative.VertexAttrib4Nusv>();

					this._VertexAttrib4Nusv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4Nusv);
		}

		private GLNative.VertexAttrib4s _VertexAttrib4s;

		/// glVertexAttrib4s
		/// Version: 2.0
		public void VertexAttrib4(uint index, short x, short y, short z, short w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4s);

			if (this._VertexAttrib4s == null)
				this._VertexAttrib4s = (GLNative.VertexAttrib4s)this.LoadExtensionFunction<GLNative.VertexAttrib4s>();

			this._VertexAttrib4s(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4s);
		}

		/// glVertexAttrib4sv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttrib4sv == null)
						this._VertexAttrib4sv = (GLNative.VertexAttrib4sv)this.LoadExtensionFunction<GLNative.VertexAttrib4sv>();

					this._VertexAttrib4sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4sv);
		}

		private GLNative.VertexAttrib4sv _VertexAttrib4sv;

		/// glVertexAttrib4sv
		/// Version: 2.0
		public void VertexAttrib4(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttrib4sv == null)
						this._VertexAttrib4sv = (GLNative.VertexAttrib4sv)this.LoadExtensionFunction<GLNative.VertexAttrib4sv>();

					this._VertexAttrib4sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4sv);
		}

		/// glVertexAttrib4ubv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4ubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					if (this._VertexAttrib4ubv == null)
						this._VertexAttrib4ubv = (GLNative.VertexAttrib4ubv)this.LoadExtensionFunction<GLNative.VertexAttrib4ubv>();

					this._VertexAttrib4ubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4ubv);
		}

		private GLNative.VertexAttrib4ubv _VertexAttrib4ubv;

		/// glVertexAttrib4ubv
		/// Version: 2.0
		public void VertexAttrib4(uint index, byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4ubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					if (this._VertexAttrib4ubv == null)
						this._VertexAttrib4ubv = (GLNative.VertexAttrib4ubv)this.LoadExtensionFunction<GLNative.VertexAttrib4ubv>();

					this._VertexAttrib4ubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4ubv);
		}

		private GLNative.VertexAttrib4uiv _VertexAttrib4uiv;

		/// glVertexAttrib4uiv
		/// Version: 2.0
		public void VertexAttrib4(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttrib4uiv == null)
						this._VertexAttrib4uiv = (GLNative.VertexAttrib4uiv)this.LoadExtensionFunction<GLNative.VertexAttrib4uiv>();

					this._VertexAttrib4uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4uiv);
		}

		/// glVertexAttrib4uiv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttrib4uiv == null)
						this._VertexAttrib4uiv = (GLNative.VertexAttrib4uiv)this.LoadExtensionFunction<GLNative.VertexAttrib4uiv>();

					this._VertexAttrib4uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4uiv);
		}

		private GLNative.VertexAttrib4usv _VertexAttrib4usv;

		/// glVertexAttrib4usv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4usv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					if (this._VertexAttrib4usv == null)
						this._VertexAttrib4usv = (GLNative.VertexAttrib4usv)this.LoadExtensionFunction<GLNative.VertexAttrib4usv>();

					this._VertexAttrib4usv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4usv);
		}

		/// glVertexAttrib4usv
		/// Version: 2.0
		public void VertexAttrib4(uint index, ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttrib4usv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					if (this._VertexAttrib4usv == null)
						this._VertexAttrib4usv = (GLNative.VertexAttrib4usv)this.LoadExtensionFunction<GLNative.VertexAttrib4usv>();

					this._VertexAttrib4usv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttrib4usv);
		}

		private GLNative.VertexAttribDivisor _VertexAttribDivisor;

		/// glVertexAttribDivisor
		/// Version: 3.3
		public void VertexAttribDivisor(uint index, uint divisor)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribDivisor);

			if (this._VertexAttribDivisor == null)
				this._VertexAttribDivisor = (GLNative.VertexAttribDivisor)this.LoadExtensionFunction<GLNative.VertexAttribDivisor>();

			this._VertexAttribDivisor(index, divisor);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribDivisor);
		}

		private GLNative.VertexAttribI1i _VertexAttribI1i;

		/// glVertexAttribI1i
		/// Version: 3.0
		public void VertexAttribI1(uint index, int x)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1i);

			if (this._VertexAttribI1i == null)
				this._VertexAttribI1i = (GLNative.VertexAttribI1i)this.LoadExtensionFunction<GLNative.VertexAttribI1i>();

			this._VertexAttribI1i(index, x);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1i);
		}

		/// glVertexAttribI1iv
		/// Version: 3.0
		public void VertexAttribI1(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttribI1iv == null)
						this._VertexAttribI1iv = (GLNative.VertexAttribI1iv)this.LoadExtensionFunction<GLNative.VertexAttribI1iv>();

					this._VertexAttribI1iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1iv);
		}

		private GLNative.VertexAttribI1iv _VertexAttribI1iv;

		/// glVertexAttribI1iv
		/// Version: 3.0
		public void VertexAttribI1(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttribI1iv == null)
						this._VertexAttribI1iv = (GLNative.VertexAttribI1iv)this.LoadExtensionFunction<GLNative.VertexAttribI1iv>();

					this._VertexAttribI1iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1iv);
		}

		private GLNative.VertexAttribI1ui _VertexAttribI1ui;

		/// glVertexAttribI1ui
		/// Version: 3.0
		public void VertexAttribI1(uint index, uint x)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1ui);

			if (this._VertexAttribI1ui == null)
				this._VertexAttribI1ui = (GLNative.VertexAttribI1ui)this.LoadExtensionFunction<GLNative.VertexAttribI1ui>();

			this._VertexAttribI1ui(index, x);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1ui);
		}

		/// glVertexAttribI1uiv
		/// Version: 3.0
		public void VertexAttribI1(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttribI1uiv == null)
						this._VertexAttribI1uiv = (GLNative.VertexAttribI1uiv)this.LoadExtensionFunction<GLNative.VertexAttribI1uiv>();

					this._VertexAttribI1uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1uiv);
		}

		private GLNative.VertexAttribI1uiv _VertexAttribI1uiv;

		/// glVertexAttribI1uiv
		/// Version: 3.0
		public void VertexAttribI1(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI1uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttribI1uiv == null)
						this._VertexAttribI1uiv = (GLNative.VertexAttribI1uiv)this.LoadExtensionFunction<GLNative.VertexAttribI1uiv>();

					this._VertexAttribI1uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI1uiv);
		}

		private GLNative.VertexAttribI2i _VertexAttribI2i;

		/// glVertexAttribI2i
		/// Version: 3.0
		public void VertexAttribI2(uint index, int x, int y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2i);

			if (this._VertexAttribI2i == null)
				this._VertexAttribI2i = (GLNative.VertexAttribI2i)this.LoadExtensionFunction<GLNative.VertexAttribI2i>();

			this._VertexAttribI2i(index, x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2i);
		}

		private GLNative.VertexAttribI2iv _VertexAttribI2iv;

		/// glVertexAttribI2iv
		/// Version: 3.0
		public void VertexAttribI2(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttribI2iv == null)
						this._VertexAttribI2iv = (GLNative.VertexAttribI2iv)this.LoadExtensionFunction<GLNative.VertexAttribI2iv>();

					this._VertexAttribI2iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2iv);
		}

		/// glVertexAttribI2iv
		/// Version: 3.0
		public void VertexAttribI2(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttribI2iv == null)
						this._VertexAttribI2iv = (GLNative.VertexAttribI2iv)this.LoadExtensionFunction<GLNative.VertexAttribI2iv>();

					this._VertexAttribI2iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2iv);
		}

		private GLNative.VertexAttribI2ui _VertexAttribI2ui;

		/// glVertexAttribI2ui
		/// Version: 3.0
		public void VertexAttribI2(uint index, uint x, uint y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2ui);

			if (this._VertexAttribI2ui == null)
				this._VertexAttribI2ui = (GLNative.VertexAttribI2ui)this.LoadExtensionFunction<GLNative.VertexAttribI2ui>();

			this._VertexAttribI2ui(index, x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2ui);
		}

		private GLNative.VertexAttribI2uiv _VertexAttribI2uiv;

		/// glVertexAttribI2uiv
		/// Version: 3.0
		public void VertexAttribI2(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttribI2uiv == null)
						this._VertexAttribI2uiv = (GLNative.VertexAttribI2uiv)this.LoadExtensionFunction<GLNative.VertexAttribI2uiv>();

					this._VertexAttribI2uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2uiv);
		}

		/// glVertexAttribI2uiv
		/// Version: 3.0
		public void VertexAttribI2(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI2uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttribI2uiv == null)
						this._VertexAttribI2uiv = (GLNative.VertexAttribI2uiv)this.LoadExtensionFunction<GLNative.VertexAttribI2uiv>();

					this._VertexAttribI2uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI2uiv);
		}

		private GLNative.VertexAttribI3i _VertexAttribI3i;

		/// glVertexAttribI3i
		/// Version: 3.0
		public void VertexAttribI3(uint index, int x, int y, int z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3i);

			if (this._VertexAttribI3i == null)
				this._VertexAttribI3i = (GLNative.VertexAttribI3i)this.LoadExtensionFunction<GLNative.VertexAttribI3i>();

			this._VertexAttribI3i(index, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3i);
		}

		/// glVertexAttribI3iv
		/// Version: 3.0
		public void VertexAttribI3(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttribI3iv == null)
						this._VertexAttribI3iv = (GLNative.VertexAttribI3iv)this.LoadExtensionFunction<GLNative.VertexAttribI3iv>();

					this._VertexAttribI3iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3iv);
		}

		private GLNative.VertexAttribI3iv _VertexAttribI3iv;

		/// glVertexAttribI3iv
		/// Version: 3.0
		public void VertexAttribI3(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttribI3iv == null)
						this._VertexAttribI3iv = (GLNative.VertexAttribI3iv)this.LoadExtensionFunction<GLNative.VertexAttribI3iv>();

					this._VertexAttribI3iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3iv);
		}

		private GLNative.VertexAttribI3ui _VertexAttribI3ui;

		/// glVertexAttribI3ui
		/// Version: 3.0
		public void VertexAttribI3(uint index, uint x, uint y, uint z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3ui);

			if (this._VertexAttribI3ui == null)
				this._VertexAttribI3ui = (GLNative.VertexAttribI3ui)this.LoadExtensionFunction<GLNative.VertexAttribI3ui>();

			this._VertexAttribI3ui(index, x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3ui);
		}

		/// glVertexAttribI3uiv
		/// Version: 3.0
		public void VertexAttribI3(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttribI3uiv == null)
						this._VertexAttribI3uiv = (GLNative.VertexAttribI3uiv)this.LoadExtensionFunction<GLNative.VertexAttribI3uiv>();

					this._VertexAttribI3uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3uiv);
		}

		private GLNative.VertexAttribI3uiv _VertexAttribI3uiv;

		/// glVertexAttribI3uiv
		/// Version: 3.0
		public void VertexAttribI3(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI3uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttribI3uiv == null)
						this._VertexAttribI3uiv = (GLNative.VertexAttribI3uiv)this.LoadExtensionFunction<GLNative.VertexAttribI3uiv>();

					this._VertexAttribI3uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI3uiv);
		}

		private GLNative.VertexAttribI4bv _VertexAttribI4bv;

		/// glVertexAttribI4bv
		/// Version: 3.0
		public void VertexAttribI4(uint index, sbyte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4bv);

			unsafe
			{
				fixed (sbyte* vPtr = v)
				{
					if (this._VertexAttribI4bv == null)
						this._VertexAttribI4bv = (GLNative.VertexAttribI4bv)this.LoadExtensionFunction<GLNative.VertexAttribI4bv>();

					this._VertexAttribI4bv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4bv);
		}

		/// glVertexAttribI4bv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref sbyte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4bv);

			unsafe
			{
				fixed (sbyte* vPtr = &v)
				{
					if (this._VertexAttribI4bv == null)
						this._VertexAttribI4bv = (GLNative.VertexAttribI4bv)this.LoadExtensionFunction<GLNative.VertexAttribI4bv>();

					this._VertexAttribI4bv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4bv);
		}

		private GLNative.VertexAttribI4i _VertexAttribI4i;

		/// glVertexAttribI4i
		/// Version: 3.0
		public void VertexAttribI4(uint index, int x, int y, int z, int w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4i);

			if (this._VertexAttribI4i == null)
				this._VertexAttribI4i = (GLNative.VertexAttribI4i)this.LoadExtensionFunction<GLNative.VertexAttribI4i>();

			this._VertexAttribI4i(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4i);
		}

		/// glVertexAttribI4iv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._VertexAttribI4iv == null)
						this._VertexAttribI4iv = (GLNative.VertexAttribI4iv)this.LoadExtensionFunction<GLNative.VertexAttribI4iv>();

					this._VertexAttribI4iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4iv);
		}

		private GLNative.VertexAttribI4iv _VertexAttribI4iv;

		/// glVertexAttribI4iv
		/// Version: 3.0
		public void VertexAttribI4(uint index, int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._VertexAttribI4iv == null)
						this._VertexAttribI4iv = (GLNative.VertexAttribI4iv)this.LoadExtensionFunction<GLNative.VertexAttribI4iv>();

					this._VertexAttribI4iv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4iv);
		}

		/// glVertexAttribI4sv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._VertexAttribI4sv == null)
						this._VertexAttribI4sv = (GLNative.VertexAttribI4sv)this.LoadExtensionFunction<GLNative.VertexAttribI4sv>();

					this._VertexAttribI4sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4sv);
		}

		private GLNative.VertexAttribI4sv _VertexAttribI4sv;

		/// glVertexAttribI4sv
		/// Version: 3.0
		public void VertexAttribI4(uint index, short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._VertexAttribI4sv == null)
						this._VertexAttribI4sv = (GLNative.VertexAttribI4sv)this.LoadExtensionFunction<GLNative.VertexAttribI4sv>();

					this._VertexAttribI4sv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4sv);
		}

		/// glVertexAttribI4ubv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref byte v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4ubv);

			unsafe
			{
				fixed (byte* vPtr = &v)
				{
					if (this._VertexAttribI4ubv == null)
						this._VertexAttribI4ubv = (GLNative.VertexAttribI4ubv)this.LoadExtensionFunction<GLNative.VertexAttribI4ubv>();

					this._VertexAttribI4ubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4ubv);
		}

		private GLNative.VertexAttribI4ubv _VertexAttribI4ubv;

		/// glVertexAttribI4ubv
		/// Version: 3.0
		public void VertexAttribI4(uint index, byte[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4ubv);

			unsafe
			{
				fixed (byte* vPtr = v)
				{
					if (this._VertexAttribI4ubv == null)
						this._VertexAttribI4ubv = (GLNative.VertexAttribI4ubv)this.LoadExtensionFunction<GLNative.VertexAttribI4ubv>();

					this._VertexAttribI4ubv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4ubv);
		}

		private GLNative.VertexAttribI4ui _VertexAttribI4ui;

		/// glVertexAttribI4ui
		/// Version: 3.0
		public void VertexAttribI4(uint index, uint x, uint y, uint z, uint w)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4ui);

			if (this._VertexAttribI4ui == null)
				this._VertexAttribI4ui = (GLNative.VertexAttribI4ui)this.LoadExtensionFunction<GLNative.VertexAttribI4ui>();

			this._VertexAttribI4ui(index, x, y, z, w);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4ui);
		}

		private GLNative.VertexAttribI4uiv _VertexAttribI4uiv;

		/// glVertexAttribI4uiv
		/// Version: 3.0
		public void VertexAttribI4(uint index, uint[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4uiv);

			unsafe
			{
				fixed (uint* vPtr = v)
				{
					if (this._VertexAttribI4uiv == null)
						this._VertexAttribI4uiv = (GLNative.VertexAttribI4uiv)this.LoadExtensionFunction<GLNative.VertexAttribI4uiv>();

					this._VertexAttribI4uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4uiv);
		}

		/// glVertexAttribI4uiv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref uint v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4uiv);

			unsafe
			{
				fixed (uint* vPtr = &v)
				{
					if (this._VertexAttribI4uiv == null)
						this._VertexAttribI4uiv = (GLNative.VertexAttribI4uiv)this.LoadExtensionFunction<GLNative.VertexAttribI4uiv>();

					this._VertexAttribI4uiv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4uiv);
		}

		/// glVertexAttribI4usv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ref ushort v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4usv);

			unsafe
			{
				fixed (ushort* vPtr = &v)
				{
					if (this._VertexAttribI4usv == null)
						this._VertexAttribI4usv = (GLNative.VertexAttribI4usv)this.LoadExtensionFunction<GLNative.VertexAttribI4usv>();

					this._VertexAttribI4usv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4usv);
		}

		private GLNative.VertexAttribI4usv _VertexAttribI4usv;

		/// glVertexAttribI4usv
		/// Version: 3.0
		public void VertexAttribI4(uint index, ushort[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribI4usv);

			unsafe
			{
				fixed (ushort* vPtr = v)
				{
					if (this._VertexAttribI4usv == null)
						this._VertexAttribI4usv = (GLNative.VertexAttribI4usv)this.LoadExtensionFunction<GLNative.VertexAttribI4usv>();

					this._VertexAttribI4usv(index, vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribI4usv);
		}

		private GLNative.VertexAttribIPointer _VertexAttribIPointer;

		/// glVertexAttribIPointer
		/// Version: 3.0
		public void VertexAttribIPointer<T>(uint index, int size, uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribIPointer == null)
						this._VertexAttribIPointer = (GLNative.VertexAttribIPointer)this.LoadExtensionFunction<GLNative.VertexAttribIPointer>();

					this._VertexAttribIPointer(index, size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);
		}

		/// glVertexAttribIPointer
		/// Version: 3.0
		public void VertexAttribIPointer<T>(uint index, int size, uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribIPointer == null)
						this._VertexAttribIPointer = (GLNative.VertexAttribIPointer)this.LoadExtensionFunction<GLNative.VertexAttribIPointer>();

					this._VertexAttribIPointer(index, size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);
		}

		/// glVertexAttribIPointer
		/// Version: 3.0
		public void VertexAttribIPointer(uint index, int size, uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);

			unsafe
			{
				if (this._VertexAttribIPointer == null)
					this._VertexAttribIPointer = (GLNative.VertexAttribIPointer)this.LoadExtensionFunction<GLNative.VertexAttribIPointer>();

				this._VertexAttribIPointer(index, size, type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribIPointer);
		}

		private GLNative.VertexAttribP1ui _VertexAttribP1ui;

		/// glVertexAttribP1ui
		/// Version: 3.3
		public void VertexAttribP1(uint index, uint type, bool normalized, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP1ui);

			if (this._VertexAttribP1ui == null)
				this._VertexAttribP1ui = (GLNative.VertexAttribP1ui)this.LoadExtensionFunction<GLNative.VertexAttribP1ui>();

			this._VertexAttribP1ui(index, type, normalized, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP1ui);
		}

		/// glVertexAttribP1uiv
		/// Version: 3.3
		public void VertexAttribP1(uint index, uint type, bool normalized, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP1uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexAttribP1uiv == null)
						this._VertexAttribP1uiv = (GLNative.VertexAttribP1uiv)this.LoadExtensionFunction<GLNative.VertexAttribP1uiv>();

					this._VertexAttribP1uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP1uiv);
		}

		private GLNative.VertexAttribP1uiv _VertexAttribP1uiv;

		/// glVertexAttribP1uiv
		/// Version: 3.3
		public void VertexAttribP1(uint index, uint type, bool normalized, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP1uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexAttribP1uiv == null)
						this._VertexAttribP1uiv = (GLNative.VertexAttribP1uiv)this.LoadExtensionFunction<GLNative.VertexAttribP1uiv>();

					this._VertexAttribP1uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP1uiv);
		}

		private GLNative.VertexAttribP2ui _VertexAttribP2ui;

		/// glVertexAttribP2ui
		/// Version: 3.3
		public void VertexAttribP2(uint index, uint type, bool normalized, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP2ui);

			if (this._VertexAttribP2ui == null)
				this._VertexAttribP2ui = (GLNative.VertexAttribP2ui)this.LoadExtensionFunction<GLNative.VertexAttribP2ui>();

			this._VertexAttribP2ui(index, type, normalized, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP2ui);
		}

		/// glVertexAttribP2uiv
		/// Version: 3.3
		public void VertexAttribP2(uint index, uint type, bool normalized, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP2uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexAttribP2uiv == null)
						this._VertexAttribP2uiv = (GLNative.VertexAttribP2uiv)this.LoadExtensionFunction<GLNative.VertexAttribP2uiv>();

					this._VertexAttribP2uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP2uiv);
		}

		private GLNative.VertexAttribP2uiv _VertexAttribP2uiv;

		/// glVertexAttribP2uiv
		/// Version: 3.3
		public void VertexAttribP2(uint index, uint type, bool normalized, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP2uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexAttribP2uiv == null)
						this._VertexAttribP2uiv = (GLNative.VertexAttribP2uiv)this.LoadExtensionFunction<GLNative.VertexAttribP2uiv>();

					this._VertexAttribP2uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP2uiv);
		}

		private GLNative.VertexAttribP3ui _VertexAttribP3ui;

		/// glVertexAttribP3ui
		/// Version: 3.3
		public void VertexAttribP3(uint index, uint type, bool normalized, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP3ui);

			if (this._VertexAttribP3ui == null)
				this._VertexAttribP3ui = (GLNative.VertexAttribP3ui)this.LoadExtensionFunction<GLNative.VertexAttribP3ui>();

			this._VertexAttribP3ui(index, type, normalized, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP3ui);
		}

		private GLNative.VertexAttribP3uiv _VertexAttribP3uiv;

		/// glVertexAttribP3uiv
		/// Version: 3.3
		public void VertexAttribP3(uint index, uint type, bool normalized, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP3uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexAttribP3uiv == null)
						this._VertexAttribP3uiv = (GLNative.VertexAttribP3uiv)this.LoadExtensionFunction<GLNative.VertexAttribP3uiv>();

					this._VertexAttribP3uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP3uiv);
		}

		/// glVertexAttribP3uiv
		/// Version: 3.3
		public void VertexAttribP3(uint index, uint type, bool normalized, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP3uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexAttribP3uiv == null)
						this._VertexAttribP3uiv = (GLNative.VertexAttribP3uiv)this.LoadExtensionFunction<GLNative.VertexAttribP3uiv>();

					this._VertexAttribP3uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP3uiv);
		}

		private GLNative.VertexAttribP4ui _VertexAttribP4ui;

		/// glVertexAttribP4ui
		/// Version: 3.3
		public void VertexAttribP4(uint index, uint type, bool normalized, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP4ui);

			if (this._VertexAttribP4ui == null)
				this._VertexAttribP4ui = (GLNative.VertexAttribP4ui)this.LoadExtensionFunction<GLNative.VertexAttribP4ui>();

			this._VertexAttribP4ui(index, type, normalized, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP4ui);
		}

		/// glVertexAttribP4uiv
		/// Version: 3.3
		public void VertexAttribP4(uint index, uint type, bool normalized, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP4uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexAttribP4uiv == null)
						this._VertexAttribP4uiv = (GLNative.VertexAttribP4uiv)this.LoadExtensionFunction<GLNative.VertexAttribP4uiv>();

					this._VertexAttribP4uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP4uiv);
		}

		private GLNative.VertexAttribP4uiv _VertexAttribP4uiv;

		/// glVertexAttribP4uiv
		/// Version: 3.3
		public void VertexAttribP4(uint index, uint type, bool normalized, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribP4uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexAttribP4uiv == null)
						this._VertexAttribP4uiv = (GLNative.VertexAttribP4uiv)this.LoadExtensionFunction<GLNative.VertexAttribP4uiv>();

					this._VertexAttribP4uiv(index, type, normalized, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribP4uiv);
		}

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer(uint index, int size, VertexAttribPointerType type, bool normalized, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				if (this._VertexAttribPointer == null)
					this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

				this._VertexAttribPointer(index, size, (uint)type, normalized, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer<T>(uint index, int size, VertexAttribPointerType type, bool normalized, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribPointer == null)
						this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

					this._VertexAttribPointer(index, size, (uint)type, normalized, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer(uint index, int size, uint type, bool normalized, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				if (this._VertexAttribPointer == null)
					this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

				this._VertexAttribPointer(index, size, type, normalized, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer<T>(uint index, int size, uint type, bool normalized, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribPointer == null)
						this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

					this._VertexAttribPointer(index, size, type, normalized, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		private GLNative.VertexAttribPointer _VertexAttribPointer;

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer<T>(uint index, int size, uint type, bool normalized, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribPointer == null)
						this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

					this._VertexAttribPointer(index, size, type, normalized, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		/// glVertexAttribPointer
		/// Version: 2.0
		public void VertexAttribPointer<T>(uint index, int size, VertexAttribPointerType type, bool normalized, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					if (this._VertexAttribPointer == null)
						this._VertexAttribPointer = (GLNative.VertexAttribPointer)this.LoadExtensionFunction<GLNative.VertexAttribPointer>();

					this._VertexAttribPointer(index, size, (uint)type, normalized, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexAttribPointer);
		}

		private GLNative.VertexP2ui _VertexP2ui;

		/// glVertexP2ui
		/// Version: 3.3
		public void VertexP2(uint type, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP2ui);

			if (this._VertexP2ui == null)
				this._VertexP2ui = (GLNative.VertexP2ui)this.LoadExtensionFunction<GLNative.VertexP2ui>();

			this._VertexP2ui(type, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP2ui);
		}

		private GLNative.VertexP2uiv _VertexP2uiv;

		/// glVertexP2uiv
		/// Version: 3.3
		public void VertexP2(uint type, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP2uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexP2uiv == null)
						this._VertexP2uiv = (GLNative.VertexP2uiv)this.LoadExtensionFunction<GLNative.VertexP2uiv>();

					this._VertexP2uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP2uiv);
		}

		/// glVertexP2uiv
		/// Version: 3.3
		public void VertexP2(uint type, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP2uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexP2uiv == null)
						this._VertexP2uiv = (GLNative.VertexP2uiv)this.LoadExtensionFunction<GLNative.VertexP2uiv>();

					this._VertexP2uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP2uiv);
		}

		private GLNative.VertexP3ui _VertexP3ui;

		/// glVertexP3ui
		/// Version: 3.3
		public void VertexP3(uint type, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP3ui);

			if (this._VertexP3ui == null)
				this._VertexP3ui = (GLNative.VertexP3ui)this.LoadExtensionFunction<GLNative.VertexP3ui>();

			this._VertexP3ui(type, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP3ui);
		}

		private GLNative.VertexP3uiv _VertexP3uiv;

		/// glVertexP3uiv
		/// Version: 3.3
		public void VertexP3(uint type, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP3uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexP3uiv == null)
						this._VertexP3uiv = (GLNative.VertexP3uiv)this.LoadExtensionFunction<GLNative.VertexP3uiv>();

					this._VertexP3uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP3uiv);
		}

		/// glVertexP3uiv
		/// Version: 3.3
		public void VertexP3(uint type, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP3uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexP3uiv == null)
						this._VertexP3uiv = (GLNative.VertexP3uiv)this.LoadExtensionFunction<GLNative.VertexP3uiv>();

					this._VertexP3uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP3uiv);
		}

		private GLNative.VertexP4ui _VertexP4ui;

		/// glVertexP4ui
		/// Version: 3.3
		public void VertexP4(uint type, uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP4ui);

			if (this._VertexP4ui == null)
				this._VertexP4ui = (GLNative.VertexP4ui)this.LoadExtensionFunction<GLNative.VertexP4ui>();

			this._VertexP4ui(type, value);

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP4ui);
		}

		private GLNative.VertexP4uiv _VertexP4uiv;

		/// glVertexP4uiv
		/// Version: 3.3
		public void VertexP4(uint type, uint[] value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP4uiv);

			unsafe
			{
				fixed (uint* valuePtr = value)
				{
					if (this._VertexP4uiv == null)
						this._VertexP4uiv = (GLNative.VertexP4uiv)this.LoadExtensionFunction<GLNative.VertexP4uiv>();

					this._VertexP4uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP4uiv);
		}

		/// glVertexP4uiv
		/// Version: 3.3
		public void VertexP4(uint type, ref uint value)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexP4uiv);

			unsafe
			{
				fixed (uint* valuePtr = &value)
				{
					if (this._VertexP4uiv == null)
						this._VertexP4uiv = (GLNative.VertexP4uiv)this.LoadExtensionFunction<GLNative.VertexP4uiv>();

					this._VertexP4uiv(type, valuePtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexP4uiv);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer(int size, uint type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GLNative.VertexPointer(size, type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer<T>(int size, VertexPointerType type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.VertexPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer<T>(int size, uint type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.VertexPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer<T>(int size, uint type, int stride, ref T pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.VertexPointer(size, type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer(int size, VertexPointerType type, int stride, IntPtr pointer)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GLNative.VertexPointer(size, (uint)type, stride, pointer);
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glVertexPointer
		/// Version: 1.1
		public void VertexPointer<T>(int size, VertexPointerType type, int stride, T[] pointer) where T : struct
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.VertexPointer);

			unsafe
			{
				GCHandle pointerPtr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
				try
				{
					GLNative.VertexPointer(size, (uint)type, stride, (IntPtr)pointerPtr.AddrOfPinnedObject());
				}
				finally
				{
					pointerPtr.Free();
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.VertexPointer);
		}

		/// glViewport
		/// Version: 1.0
		public void Viewport(int x, int y, int width, int height)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.Viewport);

			GLNative.Viewport(x, y, width, height);

			this.AfterNativeFunctionCall(GLNativeFunctions.Viewport);
		}

		private GLNative.WaitSync _WaitSync;

		/// glWaitSync
		/// Version: 3.2
		public void WaitSync(IntPtr sync, uint flags, ulong timeout)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WaitSync);

			if (this._WaitSync == null)
				this._WaitSync = (GLNative.WaitSync)this.LoadExtensionFunction<GLNative.WaitSync>();

			this._WaitSync(sync, flags, timeout);

			this.AfterNativeFunctionCall(GLNativeFunctions.WaitSync);
		}

		private GLNative.WindowPos2d _WindowPos2d;

		/// glWindowPos2d
		/// Version: 1.4
		public void WindowPos2(double x, double y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2d);

			if (this._WindowPos2d == null)
				this._WindowPos2d = (GLNative.WindowPos2d)this.LoadExtensionFunction<GLNative.WindowPos2d>();

			this._WindowPos2d(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2d);
		}

		/// glWindowPos2dv
		/// Version: 1.4
		public void WindowPos2(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._WindowPos2dv == null)
						this._WindowPos2dv = (GLNative.WindowPos2dv)this.LoadExtensionFunction<GLNative.WindowPos2dv>();

					this._WindowPos2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2dv);
		}

		private GLNative.WindowPos2dv _WindowPos2dv;

		/// glWindowPos2dv
		/// Version: 1.4
		public void WindowPos2(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._WindowPos2dv == null)
						this._WindowPos2dv = (GLNative.WindowPos2dv)this.LoadExtensionFunction<GLNative.WindowPos2dv>();

					this._WindowPos2dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2dv);
		}

		private GLNative.WindowPos2f _WindowPos2f;

		/// glWindowPos2f
		/// Version: 1.4
		public void WindowPos2(float x, float y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2f);

			if (this._WindowPos2f == null)
				this._WindowPos2f = (GLNative.WindowPos2f)this.LoadExtensionFunction<GLNative.WindowPos2f>();

			this._WindowPos2f(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2f);
		}

		/// glWindowPos2fv
		/// Version: 1.4
		public void WindowPos2(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._WindowPos2fv == null)
						this._WindowPos2fv = (GLNative.WindowPos2fv)this.LoadExtensionFunction<GLNative.WindowPos2fv>();

					this._WindowPos2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2fv);
		}

		private GLNative.WindowPos2fv _WindowPos2fv;

		/// glWindowPos2fv
		/// Version: 1.4
		public void WindowPos2(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._WindowPos2fv == null)
						this._WindowPos2fv = (GLNative.WindowPos2fv)this.LoadExtensionFunction<GLNative.WindowPos2fv>();

					this._WindowPos2fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2fv);
		}

		private GLNative.WindowPos2i _WindowPos2i;

		/// glWindowPos2i
		/// Version: 1.4
		public void WindowPos2(int x, int y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2i);

			if (this._WindowPos2i == null)
				this._WindowPos2i = (GLNative.WindowPos2i)this.LoadExtensionFunction<GLNative.WindowPos2i>();

			this._WindowPos2i(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2i);
		}

		private GLNative.WindowPos2iv _WindowPos2iv;

		/// glWindowPos2iv
		/// Version: 1.4
		public void WindowPos2(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._WindowPos2iv == null)
						this._WindowPos2iv = (GLNative.WindowPos2iv)this.LoadExtensionFunction<GLNative.WindowPos2iv>();

					this._WindowPos2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2iv);
		}

		/// glWindowPos2iv
		/// Version: 1.4
		public void WindowPos2(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._WindowPos2iv == null)
						this._WindowPos2iv = (GLNative.WindowPos2iv)this.LoadExtensionFunction<GLNative.WindowPos2iv>();

					this._WindowPos2iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2iv);
		}

		private GLNative.WindowPos2s _WindowPos2s;

		/// glWindowPos2s
		/// Version: 1.4
		public void WindowPos2(short x, short y)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2s);

			if (this._WindowPos2s == null)
				this._WindowPos2s = (GLNative.WindowPos2s)this.LoadExtensionFunction<GLNative.WindowPos2s>();

			this._WindowPos2s(x, y);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2s);
		}

		/// glWindowPos2sv
		/// Version: 1.4
		public void WindowPos2(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._WindowPos2sv == null)
						this._WindowPos2sv = (GLNative.WindowPos2sv)this.LoadExtensionFunction<GLNative.WindowPos2sv>();

					this._WindowPos2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2sv);
		}

		private GLNative.WindowPos2sv _WindowPos2sv;

		/// glWindowPos2sv
		/// Version: 1.4
		public void WindowPos2(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos2sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._WindowPos2sv == null)
						this._WindowPos2sv = (GLNative.WindowPos2sv)this.LoadExtensionFunction<GLNative.WindowPos2sv>();

					this._WindowPos2sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos2sv);
		}

		private GLNative.WindowPos3d _WindowPos3d;

		/// glWindowPos3d
		/// Version: 1.4
		public void WindowPos3(double x, double y, double z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3d);

			if (this._WindowPos3d == null)
				this._WindowPos3d = (GLNative.WindowPos3d)this.LoadExtensionFunction<GLNative.WindowPos3d>();

			this._WindowPos3d(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3d);
		}

		/// glWindowPos3dv
		/// Version: 1.4
		public void WindowPos3(ref double v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3dv);

			unsafe
			{
				fixed (double* vPtr = &v)
				{
					if (this._WindowPos3dv == null)
						this._WindowPos3dv = (GLNative.WindowPos3dv)this.LoadExtensionFunction<GLNative.WindowPos3dv>();

					this._WindowPos3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3dv);
		}

		private GLNative.WindowPos3dv _WindowPos3dv;

		/// glWindowPos3dv
		/// Version: 1.4
		public void WindowPos3(double[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3dv);

			unsafe
			{
				fixed (double* vPtr = v)
				{
					if (this._WindowPos3dv == null)
						this._WindowPos3dv = (GLNative.WindowPos3dv)this.LoadExtensionFunction<GLNative.WindowPos3dv>();

					this._WindowPos3dv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3dv);
		}

		private GLNative.WindowPos3f _WindowPos3f;

		/// glWindowPos3f
		/// Version: 1.4
		public void WindowPos3(float x, float y, float z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3f);

			if (this._WindowPos3f == null)
				this._WindowPos3f = (GLNative.WindowPos3f)this.LoadExtensionFunction<GLNative.WindowPos3f>();

			this._WindowPos3f(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3f);
		}

		private GLNative.WindowPos3fv _WindowPos3fv;

		/// glWindowPos3fv
		/// Version: 1.4
		public void WindowPos3(float[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3fv);

			unsafe
			{
				fixed (float* vPtr = v)
				{
					if (this._WindowPos3fv == null)
						this._WindowPos3fv = (GLNative.WindowPos3fv)this.LoadExtensionFunction<GLNative.WindowPos3fv>();

					this._WindowPos3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3fv);
		}

		/// glWindowPos3fv
		/// Version: 1.4
		public void WindowPos3(ref float v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3fv);

			unsafe
			{
				fixed (float* vPtr = &v)
				{
					if (this._WindowPos3fv == null)
						this._WindowPos3fv = (GLNative.WindowPos3fv)this.LoadExtensionFunction<GLNative.WindowPos3fv>();

					this._WindowPos3fv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3fv);
		}

		private GLNative.WindowPos3i _WindowPos3i;

		/// glWindowPos3i
		/// Version: 1.4
		public void WindowPos3(int x, int y, int z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3i);

			if (this._WindowPos3i == null)
				this._WindowPos3i = (GLNative.WindowPos3i)this.LoadExtensionFunction<GLNative.WindowPos3i>();

			this._WindowPos3i(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3i);
		}

		/// glWindowPos3iv
		/// Version: 1.4
		public void WindowPos3(ref int v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3iv);

			unsafe
			{
				fixed (int* vPtr = &v)
				{
					if (this._WindowPos3iv == null)
						this._WindowPos3iv = (GLNative.WindowPos3iv)this.LoadExtensionFunction<GLNative.WindowPos3iv>();

					this._WindowPos3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3iv);
		}

		private GLNative.WindowPos3iv _WindowPos3iv;

		/// glWindowPos3iv
		/// Version: 1.4
		public void WindowPos3(int[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3iv);

			unsafe
			{
				fixed (int* vPtr = v)
				{
					if (this._WindowPos3iv == null)
						this._WindowPos3iv = (GLNative.WindowPos3iv)this.LoadExtensionFunction<GLNative.WindowPos3iv>();

					this._WindowPos3iv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3iv);
		}

		private GLNative.WindowPos3s _WindowPos3s;

		/// glWindowPos3s
		/// Version: 1.4
		public void WindowPos3(short x, short y, short z)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3s);

			if (this._WindowPos3s == null)
				this._WindowPos3s = (GLNative.WindowPos3s)this.LoadExtensionFunction<GLNative.WindowPos3s>();

			this._WindowPos3s(x, y, z);

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3s);
		}

		private GLNative.WindowPos3sv _WindowPos3sv;

		/// glWindowPos3sv
		/// Version: 1.4
		public void WindowPos3(short[] v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3sv);

			unsafe
			{
				fixed (short* vPtr = v)
				{
					if (this._WindowPos3sv == null)
						this._WindowPos3sv = (GLNative.WindowPos3sv)this.LoadExtensionFunction<GLNative.WindowPos3sv>();

					this._WindowPos3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3sv);
		}

		/// glWindowPos3sv
		/// Version: 1.4
		public void WindowPos3(ref short v)
		{
			this.BeforeNativeFunctionCall(GLNativeFunctions.WindowPos3sv);

			unsafe
			{
				fixed (short* vPtr = &v)
				{
					if (this._WindowPos3sv == null)
						this._WindowPos3sv = (GLNative.WindowPos3sv)this.LoadExtensionFunction<GLNative.WindowPos3sv>();

					this._WindowPos3sv(vPtr);
				}
			}

			this.AfterNativeFunctionCall(GLNativeFunctions.WindowPos3sv);
		}

	}
}
